1 /*
2 Copyright (c) 2019 Intel Corporation
3 
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7 
8       http://www.apache.org/licenses/LICENSE-2.0
9 
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16 #pragma once
17 
18 #include "async_resp.hpp"
19 #include "dbus_utility.hpp"
20 #include "error_messages.hpp"
21 
22 #include <boost/system/error_code.hpp>
23 #include <sdbusplus/asio/property.hpp>
24 
25 #include <array>
26 #include <charconv>
27 #include <ranges>
28 #include <string_view>
29 
30 namespace redfish
31 {
32 
33 enum NetworkProtocolUnitStructFields
34 {
35     NET_PROTO_UNIT_NAME,
36     NET_PROTO_UNIT_DESC,
37     NET_PROTO_UNIT_LOAD_STATE,
38     NET_PROTO_UNIT_ACTIVE_STATE,
39     NET_PROTO_UNIT_SUB_STATE,
40     NET_PROTO_UNIT_DEVICE,
41     NET_PROTO_UNIT_OBJ_PATH,
42     NET_PROTO_UNIT_ALWAYS_0,
43     NET_PROTO_UNIT_ALWAYS_EMPTY,
44     NET_PROTO_UNIT_ALWAYS_ROOT_PATH
45 };
46 
47 enum NetworkProtocolListenResponseElements
48 {
49     NET_PROTO_LISTEN_TYPE,
50     NET_PROTO_LISTEN_STREAM
51 };
52 
53 /**
54  * @brief D-Bus Unit structure returned in array from ListUnits Method
55  */
56 using UnitStruct =
57     std::tuple<std::string, std::string, std::string, std::string, std::string,
58                std::string, sdbusplus::message::object_path, uint32_t,
59                std::string, sdbusplus::message::object_path>;
60 
61 template <typename CallbackFunc>
62 void getMainChassisId(std::shared_ptr<bmcweb::AsyncResp> asyncResp,
63                       CallbackFunc&& callback)
64 {
65     // Find managed chassis
66     constexpr std::array<std::string_view, 2> interfaces = {
67         "xyz.openbmc_project.Inventory.Item.Board",
68         "xyz.openbmc_project.Inventory.Item.Chassis"};
69     dbus::utility::getSubTree(
70         "/xyz/openbmc_project/inventory", 0, interfaces,
71         [callback = std::forward<CallbackFunc>(callback),
72          asyncResp](const boost::system::error_code& ec,
73                     const dbus::utility::MapperGetSubTreeResponse& subtree) {
74             if (ec)
75             {
76                 BMCWEB_LOG_ERROR("{}", ec);
77                 return;
78             }
79             if (subtree.empty())
80             {
81                 BMCWEB_LOG_DEBUG("Can't find chassis!");
82                 return;
83             }
84 
85             std::size_t idPos = subtree[0].first.rfind('/');
86             if (idPos == std::string::npos ||
87                 (idPos + 1) >= subtree[0].first.size())
88             {
89                 messages::internalError(asyncResp->res);
90                 BMCWEB_LOG_DEBUG("Can't parse chassis ID!");
91                 return;
92             }
93             std::string chassisId = subtree[0].first.substr(idPos + 1);
94             BMCWEB_LOG_DEBUG("chassisId = {}", chassisId);
95             callback(chassisId, asyncResp);
96         });
97 }
98 
99 template <typename CallbackFunc>
100 void getPortStatusAndPath(
101     std::span<const std::pair<std::string_view, std::string_view>>
102         protocolToDBus,
103     CallbackFunc&& callback)
104 {
105     crow::connections::systemBus->async_method_call(
106         [protocolToDBus, callback = std::forward<CallbackFunc>(callback)](
107             const boost::system::error_code& ec,
108             const std::vector<UnitStruct>& r) {
109             std::vector<std::tuple<std::string, std::string, bool>> socketData;
110             if (ec)
111             {
112                 BMCWEB_LOG_ERROR("{}", ec);
113                 // return error code
114                 callback(ec, socketData);
115                 return;
116             }
117 
118             // save all service output into vector
119             for (const UnitStruct& unit : r)
120             {
121                 // Only traverse through <xyz>.socket units
122                 const std::string& unitName =
123                     std::get<NET_PROTO_UNIT_NAME>(unit);
124 
125                 // find "." into unitsName
126                 size_t lastCharPos = unitName.rfind('.');
127                 if (lastCharPos == std::string::npos)
128                 {
129                     continue;
130                 }
131 
132                 // is unitsName end with ".socket"
133                 std::string unitNameEnd = unitName.substr(lastCharPos);
134                 if (unitNameEnd != ".socket")
135                 {
136                     continue;
137                 }
138 
139                 // find "@" into unitsName
140                 if (size_t atCharPos = unitName.rfind('@');
141                     atCharPos != std::string::npos)
142                 {
143                     lastCharPos = atCharPos;
144                 }
145 
146                 // unitsName without "@eth(x).socket", only <xyz>
147                 // unitsName without ".socket", only <xyz>
148                 std::string unitNameStr = unitName.substr(0, lastCharPos);
149 
150                 for (const auto& kv : protocolToDBus)
151                 {
152                     // We are interested in services, which starts with
153                     // mapped service name
154                     if (unitNameStr != kv.second)
155                     {
156                         continue;
157                     }
158 
159                     const std::string& socketPath =
160                         std::get<NET_PROTO_UNIT_OBJ_PATH>(unit);
161                     const std::string& unitState =
162                         std::get<NET_PROTO_UNIT_SUB_STATE>(unit);
163 
164                     bool isProtocolEnabled = ((unitState == "running") ||
165                                               (unitState == "listening"));
166 
167                     // Some protocols may have multiple services associated with
168                     // them (for example IPMI). Look to see if we've already
169                     // added an entry for the current protocol.
170                     auto find = std::ranges::find_if(
171                         socketData,
172                         [&kv](const std::tuple<std::string, std::string, bool>&
173                                   i) { return std::get<1>(i) == kv.first; });
174                     if (find != socketData.end())
175                     {
176                         // It only takes one enabled systemd service to consider
177                         // a protocol enabled so if the current entry already
178                         // has it enabled (or the new one is disabled) then just
179                         // continue, otherwise remove the current one and add
180                         // this new one.
181                         if (std::get<2>(*find) || !isProtocolEnabled)
182                         {
183                             // Already registered as enabled or current one is
184                             // not enabled, nothing to do
185                             BMCWEB_LOG_DEBUG(
186                                 "protocolName: {}, already true or current one is false: {}",
187                                 kv.first, isProtocolEnabled);
188                             break;
189                         }
190                         // Remove existing entry and replace with new one
191                         // (below)
192                         socketData.erase(find);
193                     }
194 
195                     socketData.emplace_back(socketPath, std::string(kv.first),
196                                             isProtocolEnabled);
197                     // We found service, return from inner loop.
198                     break;
199                 }
200             }
201 
202             callback(ec, socketData);
203         },
204         "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
205         "org.freedesktop.systemd1.Manager", "ListUnits");
206 }
207 
208 template <typename CallbackFunc>
209 void getPortNumber(const std::string& socketPath, CallbackFunc&& callback)
210 {
211     sdbusplus::asio::getProperty<
212         std::vector<std::tuple<std::string, std::string>>>(
213         *crow::connections::systemBus, "org.freedesktop.systemd1", socketPath,
214         "org.freedesktop.systemd1.Socket", "Listen",
215         [callback = std::forward<CallbackFunc>(callback)](
216             const boost::system::error_code& ec,
217             const std::vector<std::tuple<std::string, std::string>>& resp) {
218             if (ec)
219             {
220                 BMCWEB_LOG_ERROR("{}", ec);
221                 callback(ec, 0);
222                 return;
223             }
224             if (resp.empty())
225             {
226                 // Network Protocol Listen Response Elements is empty
227                 boost::system::error_code ec1 =
228                     boost::system::errc::make_error_code(
229                         boost::system::errc::bad_message);
230                 // return error code
231                 callback(ec1, 0);
232                 BMCWEB_LOG_ERROR("{}", ec1);
233                 return;
234             }
235             const std::string& listenStream =
236                 std::get<NET_PROTO_LISTEN_STREAM>(resp[0]);
237             const char* pa = &listenStream[listenStream.rfind(':') + 1];
238             int port{0};
239             if (auto [p, ec2] = std::from_chars(pa, nullptr, port);
240                 ec2 != std::errc())
241             {
242                 // there is only two possibility invalid_argument and
243                 // result_out_of_range
244                 boost::system::error_code ec3 =
245                     boost::system::errc::make_error_code(
246                         boost::system::errc::invalid_argument);
247                 if (ec2 == std::errc::result_out_of_range)
248                 {
249                     ec3 = boost::system::errc::make_error_code(
250                         boost::system::errc::result_out_of_range);
251                 }
252                 // return error code
253                 callback(ec3, 0);
254                 BMCWEB_LOG_ERROR("{}", ec3);
255             }
256             callback(ec, port);
257         });
258 }
259 
260 } // namespace redfish
261