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 #ifndef BMCWEB_ENABLE_REDFISH_ONE_CHASSIS
18 
19 #include "async_resp.hpp"
20 #include "dbus_utility.hpp"
21 #include "error_messages.hpp"
22 
23 #include <boost/system/error_code.hpp>
24 #include <sdbusplus/asio/property.hpp>
25 
26 #include <array>
27 #include <charconv>
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,
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 = std::get<NET_PROTO_UNIT_NAME>(unit);
123 
124             // find "." into unitsName
125             size_t lastCharPos = unitName.rfind('.');
126             if (lastCharPos == std::string::npos)
127             {
128                 continue;
129             }
130 
131             // is unitsName end with ".socket"
132             std::string unitNameEnd = unitName.substr(lastCharPos);
133             if (unitNameEnd != ".socket")
134             {
135                 continue;
136             }
137 
138             // find "@" into unitsName
139             if (size_t atCharPos = unitName.rfind('@');
140                 atCharPos != std::string::npos)
141             {
142                 lastCharPos = atCharPos;
143             }
144 
145             // unitsName without "@eth(x).socket", only <xyz>
146             // unitsName without ".socket", only <xyz>
147             std::string unitNameStr = unitName.substr(0, lastCharPos);
148 
149             for (const auto& kv : protocolToDBus)
150             {
151                 // We are interested in services, which starts with
152                 // mapped service name
153                 if (unitNameStr != kv.second)
154                 {
155                     continue;
156                 }
157 
158                 const std::string& socketPath =
159                     std::get<NET_PROTO_UNIT_OBJ_PATH>(unit);
160                 const std::string& unitState =
161                     std::get<NET_PROTO_UNIT_SUB_STATE>(unit);
162 
163                 bool isProtocolEnabled =
164                     ((unitState == "running") || (unitState == "listening"));
165 
166                 socketData.emplace_back(socketPath, std::string(kv.first),
167                                         isProtocolEnabled);
168                 // We found service, return from inner loop.
169                 break;
170             }
171         }
172 
173         callback(ec, socketData);
174         },
175         "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
176         "org.freedesktop.systemd1.Manager", "ListUnits");
177 }
178 
179 template <typename CallbackFunc>
180 void getPortNumber(const std::string& socketPath, CallbackFunc&& callback)
181 {
182     sdbusplus::asio::getProperty<
183         std::vector<std::tuple<std::string, std::string>>>(
184         *crow::connections::systemBus, "org.freedesktop.systemd1", socketPath,
185         "org.freedesktop.systemd1.Socket", "Listen",
186         [callback{std::forward<CallbackFunc>(callback)}](
187             const boost::system::error_code& ec,
188             const std::vector<std::tuple<std::string, std::string>>& resp) {
189         if (ec)
190         {
191             BMCWEB_LOG_ERROR << ec;
192             callback(ec, 0);
193             return;
194         }
195         if (resp.empty())
196         {
197             // Network Protocol Listen Response Elements is empty
198             boost::system::error_code ec1 =
199                 boost::system::errc::make_error_code(
200                     boost::system::errc::bad_message);
201             // return error code
202             callback(ec1, 0);
203             BMCWEB_LOG_ERROR << ec1;
204             return;
205         }
206         const std::string& listenStream =
207             std::get<NET_PROTO_LISTEN_STREAM>(resp[0]);
208         const char* pa = &listenStream[listenStream.rfind(':') + 1];
209         int port{0};
210         if (auto [p, ec2] = std::from_chars(pa, nullptr, port);
211             ec2 != std::errc())
212         {
213             // there is only two possibility invalid_argument and
214             // result_out_of_range
215             boost::system::error_code ec3 =
216                 boost::system::errc::make_error_code(
217                     boost::system::errc::invalid_argument);
218             if (ec2 == std::errc::result_out_of_range)
219             {
220                 ec3 = boost::system::errc::make_error_code(
221                     boost::system::errc::result_out_of_range);
222             }
223             // return error code
224             callback(ec3, 0);
225             BMCWEB_LOG_ERROR << ec3;
226         }
227         callback(ec, port);
228         });
229 }
230 
231 } // namespace redfish
232 #endif
233