1 /* 2 // Copyright (c) 2018 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 "error_messages.hpp" 19 #include "node.hpp" 20 #include "openbmc_dbus_rest.hpp" 21 22 #include <utils/json_utils.hpp> 23 24 #include <optional> 25 #include <variant> 26 namespace redfish 27 { 28 29 enum NetworkProtocolUnitStructFields 30 { 31 NET_PROTO_UNIT_NAME, 32 NET_PROTO_UNIT_DESC, 33 NET_PROTO_UNIT_LOAD_STATE, 34 NET_PROTO_UNIT_ACTIVE_STATE, 35 NET_PROTO_UNIT_SUB_STATE, 36 NET_PROTO_UNIT_DEVICE, 37 NET_PROTO_UNIT_OBJ_PATH, 38 NET_PROTO_UNIT_ALWAYS_0, 39 NET_PROTO_UNIT_ALWAYS_EMPTY, 40 NET_PROTO_UNIT_ALWAYS_ROOT_PATH 41 }; 42 43 enum NetworkProtocolListenResponseElements 44 { 45 NET_PROTO_LISTEN_TYPE, 46 NET_PROTO_LISTEN_STREAM 47 }; 48 49 /** 50 * @brief D-Bus Unit structure returned in array from ListUnits Method 51 */ 52 using UnitStruct = 53 std::tuple<std::string, std::string, std::string, std::string, std::string, 54 std::string, sdbusplus::message::object_path, uint32_t, 55 std::string, sdbusplus::message::object_path>; 56 57 const static boost::container::flat_map<const char*, std::string> 58 protocolToDBus{{"SSH", "dropbear"}, 59 {"HTTPS", "bmcweb"}, 60 {"IPMI", "phosphor-ipmi-net"}}; 61 62 inline void 63 extractNTPServersAndDomainNamesData(const GetManagedObjects& dbus_data, 64 std::vector<std::string>& ntpData, 65 std::vector<std::string>& dnData) 66 { 67 for (const auto& obj : dbus_data) 68 { 69 for (const auto& ifacePair : obj.second) 70 { 71 if (obj.first == "/xyz/openbmc_project/network/eth0") 72 { 73 if (ifacePair.first == 74 "xyz.openbmc_project.Network.EthernetInterface") 75 { 76 for (const auto& propertyPair : ifacePair.second) 77 { 78 if (propertyPair.first == "NTPServers") 79 { 80 const std::vector<std::string>* ntpServers = 81 std::get_if<std::vector<std::string>>( 82 &propertyPair.second); 83 if (ntpServers != nullptr) 84 { 85 ntpData = std::move(*ntpServers); 86 } 87 } 88 else if (propertyPair.first == "DomainName") 89 { 90 const std::vector<std::string>* domainNames = 91 std::get_if<std::vector<std::string>>( 92 &propertyPair.second); 93 if (domainNames != nullptr) 94 { 95 dnData = std::move(*domainNames); 96 } 97 } 98 } 99 } 100 } 101 } 102 } 103 } 104 105 template <typename CallbackFunc> 106 void getEthernetIfaceData(CallbackFunc&& callback) 107 { 108 crow::connections::systemBus->async_method_call( 109 [callback{std::move(callback)}]( 110 const boost::system::error_code error_code, 111 const GetManagedObjects& dbus_data) { 112 std::vector<std::string> ntpServers; 113 std::vector<std::string> domainNames; 114 115 if (error_code) 116 { 117 callback(false, ntpServers, domainNames); 118 return; 119 } 120 121 extractNTPServersAndDomainNamesData(dbus_data, ntpServers, 122 domainNames); 123 124 callback(true, ntpServers, domainNames); 125 }, 126 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network", 127 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects"); 128 } 129 130 class NetworkProtocol : public Node 131 { 132 public: 133 NetworkProtocol(App& app) : 134 Node(app, "/redfish/v1/Managers/bmc/NetworkProtocol/") 135 { 136 entityPrivileges = { 137 {boost::beast::http::verb::get, {{"Login"}}}, 138 {boost::beast::http::verb::head, {{"Login"}}}, 139 {boost::beast::http::verb::patch, {{"ConfigureManager"}}}, 140 {boost::beast::http::verb::put, {{"ConfigureManager"}}}, 141 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}}, 142 {boost::beast::http::verb::post, {{"ConfigureManager"}}}}; 143 } 144 145 private: 146 void doGet(crow::Response& res, const crow::Request&, 147 const std::vector<std::string>&) override 148 { 149 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 150 151 getData(asyncResp); 152 } 153 154 std::string getHostName() const 155 { 156 std::string hostName; 157 158 std::array<char, HOST_NAME_MAX> hostNameCStr; 159 if (gethostname(hostNameCStr.data(), hostNameCStr.size()) == 0) 160 { 161 hostName = hostNameCStr.data(); 162 } 163 return hostName; 164 } 165 166 void getNTPProtocolEnabled(const std::shared_ptr<AsyncResp>& asyncResp) 167 { 168 crow::connections::systemBus->async_method_call( 169 [asyncResp](const boost::system::error_code error_code, 170 const std::variant<std::string>& timeSyncMethod) { 171 if (error_code) 172 { 173 return; 174 } 175 176 const std::string* s = 177 std::get_if<std::string>(&timeSyncMethod); 178 179 if (*s == "xyz.openbmc_project.Time.Synchronization.Method.NTP") 180 { 181 asyncResp->res.jsonValue["NTP"]["ProtocolEnabled"] = true; 182 } 183 else if (*s == "xyz.openbmc_project.Time.Synchronization." 184 "Method.Manual") 185 { 186 asyncResp->res.jsonValue["NTP"]["ProtocolEnabled"] = false; 187 } 188 }, 189 "xyz.openbmc_project.Settings", 190 "/xyz/openbmc_project/time/sync_method", 191 "org.freedesktop.DBus.Properties", "Get", 192 "xyz.openbmc_project.Time.Synchronization", "TimeSyncMethod"); 193 } 194 195 void getData(const std::shared_ptr<AsyncResp>& asyncResp) 196 { 197 asyncResp->res.jsonValue["@odata.type"] = 198 "#ManagerNetworkProtocol.v1_5_0.ManagerNetworkProtocol"; 199 asyncResp->res.jsonValue["@odata.id"] = 200 "/redfish/v1/Managers/bmc/NetworkProtocol"; 201 asyncResp->res.jsonValue["Id"] = "NetworkProtocol"; 202 asyncResp->res.jsonValue["Name"] = "Manager Network Protocol"; 203 asyncResp->res.jsonValue["Description"] = "Manager Network Service"; 204 asyncResp->res.jsonValue["Status"]["Health"] = "OK"; 205 asyncResp->res.jsonValue["Status"]["HealthRollup"] = "OK"; 206 asyncResp->res.jsonValue["Status"]["State"] = "Enabled"; 207 208 // HTTP is Mandatory attribute as per OCP Baseline Profile - v1.0.0, 209 // but from security perspective it is not recommended to use. 210 // Hence using protocolEnabled as false to make it OCP and security-wise 211 // compliant 212 asyncResp->res.jsonValue["HTTP"]["Port"] = 0; 213 asyncResp->res.jsonValue["HTTP"]["ProtocolEnabled"] = false; 214 215 for (auto& protocol : protocolToDBus) 216 { 217 asyncResp->res.jsonValue[protocol.first]["Port"] = 218 nlohmann::detail::value_t::null; 219 asyncResp->res.jsonValue[protocol.first]["ProtocolEnabled"] = false; 220 } 221 222 std::string hostName = getHostName(); 223 224 asyncResp->res.jsonValue["HostName"] = hostName; 225 226 getNTPProtocolEnabled(asyncResp); 227 228 // TODO Get eth0 interface data, and call the below callback for JSON 229 // preparation 230 getEthernetIfaceData( 231 [hostName, asyncResp](const bool& success, 232 const std::vector<std::string>& ntpServers, 233 const std::vector<std::string>& domainNames) { 234 if (!success) 235 { 236 messages::resourceNotFound(asyncResp->res, 237 "EthernetInterface", "eth0"); 238 return; 239 } 240 asyncResp->res.jsonValue["NTP"]["NTPServers"] = ntpServers; 241 if (hostName.empty() == false) 242 { 243 std::string fqdn = std::move(hostName); 244 if (domainNames.empty() == false) 245 { 246 fqdn += "." + domainNames[0]; 247 } 248 asyncResp->res.jsonValue["FQDN"] = std::move(fqdn); 249 } 250 }); 251 252 crow::connections::systemBus->async_method_call( 253 [asyncResp](const boost::system::error_code e, 254 const std::vector<UnitStruct>& r) { 255 if (e) 256 { 257 asyncResp->res.jsonValue = nlohmann::json::object(); 258 messages::internalError(asyncResp->res); 259 return; 260 } 261 asyncResp->res.jsonValue["HTTPS"]["Certificates"] = { 262 {"@odata.id", "/redfish/v1/Managers/bmc/NetworkProtocol/" 263 "HTTPS/Certificates"}}; 264 265 for (auto& unit : r) 266 { 267 /* Only traverse through <xyz>.socket units */ 268 std::string unitName = std::get<NET_PROTO_UNIT_NAME>(unit); 269 if (!boost::ends_with(unitName, ".socket")) 270 { 271 continue; 272 } 273 274 for (auto& kv : protocolToDBus) 275 { 276 // We are interested in services, which starts with 277 // mapped service name 278 if (!boost::starts_with(unitName, kv.second)) 279 { 280 continue; 281 } 282 const char* rfServiceKey = kv.first; 283 std::string socketPath = 284 std::get<NET_PROTO_UNIT_OBJ_PATH>(unit); 285 std::string unitState = 286 std::get<NET_PROTO_UNIT_SUB_STATE>(unit); 287 288 asyncResp->res 289 .jsonValue[rfServiceKey]["ProtocolEnabled"] = 290 (unitState == "running") || 291 (unitState == "listening"); 292 293 crow::connections::systemBus->async_method_call( 294 [asyncResp, 295 rfServiceKey{std::string(rfServiceKey)}]( 296 const boost::system::error_code ec, 297 const std::variant<std::vector<std::tuple< 298 std::string, std::string>>>& resp) { 299 if (ec) 300 { 301 messages::internalError(asyncResp->res); 302 return; 303 } 304 const std::vector< 305 std::tuple<std::string, std::string>>* 306 responsePtr = std::get_if<std::vector< 307 std::tuple<std::string, std::string>>>( 308 &resp); 309 if (responsePtr == nullptr || 310 responsePtr->size() < 1) 311 { 312 return; 313 } 314 315 const std::string& listenStream = 316 std::get<NET_PROTO_LISTEN_STREAM>( 317 (*responsePtr)[0]); 318 std::size_t lastColonPos = 319 listenStream.rfind(":"); 320 if (lastColonPos == std::string::npos) 321 { 322 // Not a port 323 return; 324 } 325 std::string portStr = 326 listenStream.substr(lastColonPos + 1); 327 if (portStr.empty()) 328 { 329 return; 330 } 331 char* endPtr = nullptr; 332 errno = 0; 333 // Use strtol instead of stroi to avoid 334 // exceptions 335 long port = 336 std::strtol(portStr.c_str(), &endPtr, 10); 337 if ((errno == 0) && (*endPtr == '\0')) 338 { 339 asyncResp->res 340 .jsonValue[rfServiceKey]["Port"] = port; 341 } 342 return; 343 }, 344 "org.freedesktop.systemd1", socketPath, 345 "org.freedesktop.DBus.Properties", "Get", 346 "org.freedesktop.systemd1.Socket", "Listen"); 347 348 // We found service, break the inner loop. 349 break; 350 } 351 } 352 }, 353 "org.freedesktop.systemd1", "/org/freedesktop/systemd1", 354 "org.freedesktop.systemd1.Manager", "ListUnits"); 355 } 356 357 void handleHostnamePatch(const std::string& hostName, 358 const std::shared_ptr<AsyncResp>& asyncResp) 359 { 360 crow::connections::systemBus->async_method_call( 361 [asyncResp](const boost::system::error_code ec) { 362 if (ec) 363 { 364 messages::internalError(asyncResp->res); 365 return; 366 } 367 }, 368 "xyz.openbmc_project.Network", 369 "/xyz/openbmc_project/network/config", 370 "org.freedesktop.DBus.Properties", "Set", 371 "xyz.openbmc_project.Network.SystemConfiguration", "HostName", 372 std::variant<std::string>(hostName)); 373 } 374 375 void handleNTPProtocolEnabled(const bool& ntpEnabled, 376 const std::shared_ptr<AsyncResp>& asyncResp) 377 { 378 std::string timeSyncMethod; 379 if (ntpEnabled) 380 { 381 timeSyncMethod = 382 "xyz.openbmc_project.Time.Synchronization.Method.NTP"; 383 } 384 else 385 { 386 timeSyncMethod = 387 "xyz.openbmc_project.Time.Synchronization.Method.Manual"; 388 } 389 390 crow::connections::systemBus->async_method_call( 391 [asyncResp](const boost::system::error_code error_code) { 392 if (error_code) 393 { 394 messages::internalError(asyncResp->res); 395 } 396 }, 397 "xyz.openbmc_project.Settings", 398 "/xyz/openbmc_project/time/sync_method", 399 "org.freedesktop.DBus.Properties", "Set", 400 "xyz.openbmc_project.Time.Synchronization", "TimeSyncMethod", 401 std::variant<std::string>{timeSyncMethod}); 402 } 403 404 void handleNTPServersPatch(const std::vector<std::string>& ntpServers, 405 const std::shared_ptr<AsyncResp>& asyncResp) 406 { 407 crow::connections::systemBus->async_method_call( 408 [asyncResp](const boost::system::error_code ec) { 409 if (ec) 410 { 411 messages::internalError(asyncResp->res); 412 return; 413 } 414 }, 415 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network/eth0", 416 "org.freedesktop.DBus.Properties", "Set", 417 "xyz.openbmc_project.Network.EthernetInterface", "NTPServers", 418 std::variant<std::vector<std::string>>{ntpServers}); 419 } 420 421 void handleIpmiProtocolEnabled(const bool ipmiProtocolEnabled, 422 const std::shared_ptr<AsyncResp>& asyncResp) 423 { 424 crow::connections::systemBus->async_method_call( 425 [ipmiProtocolEnabled, 426 asyncResp](const boost::system::error_code ec, 427 const crow::openbmc_mapper::GetSubTreeType& subtree) { 428 if (ec) 429 { 430 messages::internalError(asyncResp->res); 431 return; 432 } 433 434 constexpr char const* netipmidBasePath = 435 "/xyz/openbmc_project/control/service/" 436 "phosphor_2dipmi_2dnet_40"; 437 438 for (const auto& entry : subtree) 439 { 440 if (boost::algorithm::starts_with(entry.first, 441 netipmidBasePath)) 442 { 443 crow::connections::systemBus->async_method_call( 444 [asyncResp](const boost::system::error_code ec2) { 445 if (ec2) 446 { 447 messages::internalError(asyncResp->res); 448 return; 449 } 450 }, 451 entry.second.begin()->first, entry.first, 452 "org.freedesktop.DBus.Properties", "Set", 453 "xyz.openbmc_project.Control.Service.Attributes", 454 "Running", std::variant<bool>{ipmiProtocolEnabled}); 455 456 crow::connections::systemBus->async_method_call( 457 [asyncResp](const boost::system::error_code ec2) { 458 if (ec2) 459 { 460 messages::internalError(asyncResp->res); 461 return; 462 } 463 }, 464 entry.second.begin()->first, entry.first, 465 "org.freedesktop.DBus.Properties", "Set", 466 "xyz.openbmc_project.Control.Service.Attributes", 467 "Enabled", std::variant<bool>{ipmiProtocolEnabled}); 468 } 469 } 470 }, 471 "xyz.openbmc_project.ObjectMapper", 472 "/xyz/openbmc_project/object_mapper", 473 "xyz.openbmc_project.ObjectMapper", "GetSubTree", 474 "/xyz/openbmc_project/control/service", 0, 475 std::array<const char*, 1>{ 476 "xyz.openbmc_project.Control.Service.Attributes"}); 477 } 478 479 void doPatch(crow::Response& res, const crow::Request& req, 480 const std::vector<std::string>&) override 481 { 482 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 483 std::optional<std::string> newHostName; 484 std::optional<nlohmann::json> ntp; 485 std::optional<nlohmann::json> ipmi; 486 487 if (!json_util::readJson(req, res, "HostName", newHostName, "NTP", ntp, 488 "IPMI", ipmi)) 489 { 490 return; 491 } 492 493 res.result(boost::beast::http::status::no_content); 494 if (newHostName) 495 { 496 handleHostnamePatch(*newHostName, asyncResp); 497 } 498 499 if (ntp) 500 { 501 std::optional<std::vector<std::string>> ntpServers; 502 std::optional<bool> ntpEnabled; 503 if (!json_util::readJson(*ntp, res, "NTPServers", ntpServers, 504 "ProtocolEnabled", ntpEnabled)) 505 { 506 return; 507 } 508 509 if (ntpEnabled) 510 { 511 handleNTPProtocolEnabled(*ntpEnabled, asyncResp); 512 } 513 514 if (ntpServers) 515 { 516 std::sort((*ntpServers).begin(), (*ntpServers).end()); 517 (*ntpServers) 518 .erase( 519 std::unique((*ntpServers).begin(), (*ntpServers).end()), 520 (*ntpServers).end()); 521 handleNTPServersPatch(*ntpServers, asyncResp); 522 } 523 } 524 525 if (ipmi) 526 { 527 std::optional<bool> ipmiProtocolEnabled; 528 if (!json_util::readJson(*ipmi, res, "ProtocolEnabled", 529 ipmiProtocolEnabled)) 530 { 531 return; 532 } 533 534 if (ipmiProtocolEnabled) 535 { 536 handleIpmiProtocolEnabled(*ipmiProtocolEnabled, asyncResp); 537 } 538 } 539 } 540 }; 541 542 } // namespace redfish 543