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> 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> 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> 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