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