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 "node.hpp" 19 20 #include <boost/container/flat_map.hpp> 21 #include <utils/fw_utils.hpp> 22 #include <variant> 23 24 namespace redfish 25 { 26 27 // Match signals added on software path 28 static std::unique_ptr<sdbusplus::bus::match::match> fwUpdateMatcher; 29 // Only allow one update at a time 30 static bool fwUpdateInProgress = false; 31 // Timer for software available 32 static std::unique_ptr<boost::asio::deadline_timer> fwAvailableTimer; 33 34 static void cleanUp() 35 { 36 fwUpdateInProgress = false; 37 fwUpdateMatcher = nullptr; 38 } 39 static void activateImage(const std::string &objPath, 40 const std::string &service) 41 { 42 BMCWEB_LOG_DEBUG << "Activate image for " << objPath << " " << service; 43 crow::connections::systemBus->async_method_call( 44 [](const boost::system::error_code error_code) { 45 if (error_code) 46 { 47 BMCWEB_LOG_DEBUG << "error_code = " << error_code; 48 BMCWEB_LOG_DEBUG << "error msg = " << error_code.message(); 49 } 50 }, 51 service, objPath, "org.freedesktop.DBus.Properties", "Set", 52 "xyz.openbmc_project.Software.Activation", "RequestedActivation", 53 std::variant<std::string>( 54 "xyz.openbmc_project.Software.Activation.RequestedActivations." 55 "Active")); 56 } 57 58 // Note that asyncResp can be either a valid pointer or nullptr. If nullptr 59 // then no asyncResp updates will occur 60 static void softwareInterfaceAdded(std::shared_ptr<AsyncResp> asyncResp, 61 sdbusplus::message::message &m) 62 { 63 std::vector<std::pair< 64 std::string, 65 std::vector<std::pair<std::string, std::variant<std::string>>>>> 66 interfacesProperties; 67 68 sdbusplus::message::object_path objPath; 69 70 m.read(objPath, interfacesProperties); 71 72 BMCWEB_LOG_DEBUG << "obj path = " << objPath.str; 73 for (auto &interface : interfacesProperties) 74 { 75 BMCWEB_LOG_DEBUG << "interface = " << interface.first; 76 77 if (interface.first == "xyz.openbmc_project.Software.Activation") 78 { 79 // Found our interface, disable callbacks 80 fwUpdateMatcher = nullptr; 81 82 // Retrieve service and activate 83 crow::connections::systemBus->async_method_call( 84 [objPath, asyncResp]( 85 const boost::system::error_code error_code, 86 const std::vector<std::pair< 87 std::string, std::vector<std::string>>> &objInfo) { 88 if (error_code) 89 { 90 BMCWEB_LOG_DEBUG << "error_code = " << error_code; 91 BMCWEB_LOG_DEBUG << "error msg = " 92 << error_code.message(); 93 if (asyncResp) 94 { 95 messages::internalError(asyncResp->res); 96 } 97 cleanUp(); 98 return; 99 } 100 // Ensure we only got one service back 101 if (objInfo.size() != 1) 102 { 103 BMCWEB_LOG_ERROR << "Invalid Object Size " 104 << objInfo.size(); 105 if (asyncResp) 106 { 107 messages::internalError(asyncResp->res); 108 } 109 cleanUp(); 110 return; 111 } 112 // cancel timer only when 113 // xyz.openbmc_project.Software.Activation interface 114 // is added 115 fwAvailableTimer = nullptr; 116 117 activateImage(objPath.str, objInfo[0].first); 118 if (asyncResp) 119 { 120 redfish::messages::success(asyncResp->res); 121 } 122 fwUpdateInProgress = false; 123 }, 124 "xyz.openbmc_project.ObjectMapper", 125 "/xyz/openbmc_project/object_mapper", 126 "xyz.openbmc_project.ObjectMapper", "GetObject", objPath.str, 127 std::array<const char *, 1>{ 128 "xyz.openbmc_project.Software.Activation"}); 129 } 130 } 131 } 132 133 // Note that asyncResp can be either a valid pointer or nullptr. If nullptr 134 // then no asyncResp updates will occur 135 static void monitorForSoftwareAvailable(std::shared_ptr<AsyncResp> asyncResp, 136 const crow::Request &req, 137 int timeoutTimeSeconds = 5) 138 { 139 // Only allow one FW update at a time 140 if (fwUpdateInProgress != false) 141 { 142 if (asyncResp) 143 { 144 asyncResp->res.addHeader("Retry-After", "30"); 145 messages::serviceTemporarilyUnavailable(asyncResp->res, "30"); 146 } 147 return; 148 } 149 150 fwAvailableTimer = 151 std::make_unique<boost::asio::deadline_timer>(*req.ioService); 152 153 fwAvailableTimer->expires_from_now( 154 boost::posix_time::seconds(timeoutTimeSeconds)); 155 156 fwAvailableTimer->async_wait( 157 [asyncResp](const boost::system::error_code &ec) { 158 cleanUp(); 159 if (ec == boost::asio::error::operation_aborted) 160 { 161 // expected, we were canceled before the timer completed. 162 return; 163 } 164 BMCWEB_LOG_ERROR 165 << "Timed out waiting for firmware object being created"; 166 BMCWEB_LOG_ERROR 167 << "FW image may has already been uploaded to server"; 168 if (ec) 169 { 170 BMCWEB_LOG_ERROR << "Async_wait failed" << ec; 171 return; 172 } 173 if (asyncResp) 174 { 175 redfish::messages::internalError(asyncResp->res); 176 } 177 }); 178 179 auto callback = [asyncResp](sdbusplus::message::message &m) { 180 BMCWEB_LOG_DEBUG << "Match fired"; 181 softwareInterfaceAdded(asyncResp, m); 182 }; 183 184 fwUpdateInProgress = true; 185 186 fwUpdateMatcher = std::make_unique<sdbusplus::bus::match::match>( 187 *crow::connections::systemBus, 188 "interface='org.freedesktop.DBus.ObjectManager',type='signal'," 189 "member='InterfacesAdded',path='/xyz/openbmc_project/software'", 190 callback); 191 } 192 193 /** 194 * UpdateServiceActionsSimpleUpdate class supports handle POST method for 195 * SimpleUpdate action. 196 */ 197 class UpdateServiceActionsSimpleUpdate : public Node 198 { 199 public: 200 UpdateServiceActionsSimpleUpdate(CrowApp &app) : 201 Node(app, 202 "/redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate/") 203 { 204 entityPrivileges = { 205 {boost::beast::http::verb::get, {{"Login"}}}, 206 {boost::beast::http::verb::head, {{"Login"}}}, 207 {boost::beast::http::verb::patch, {{"ConfigureManager"}}}, 208 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 209 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 210 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 211 } 212 213 private: 214 void doPost(crow::Response &res, const crow::Request &req, 215 const std::vector<std::string> ¶ms) override 216 { 217 std::optional<std::string> transferProtocol; 218 std::string imageURI; 219 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 220 221 BMCWEB_LOG_DEBUG << "Enter UpdateService.SimpleUpdate doPost"; 222 223 // User can pass in both TransferProtocol and ImageURI parameters or 224 // they can pass in just the ImageURI with the transfer protocl embedded 225 // within it. 226 // 1) TransferProtocol:TFTP ImageURI:1.1.1.1/myfile.bin 227 // 2) ImageURI:tftp://1.1.1.1/myfile.bin 228 229 if (!json_util::readJson(req, asyncResp->res, "TransferProtocol", 230 transferProtocol, "ImageURI", imageURI)) 231 { 232 BMCWEB_LOG_DEBUG 233 << "Missing TransferProtocol or ImageURI parameter"; 234 return; 235 } 236 if (!transferProtocol) 237 { 238 // Must be option 2 239 // Verify ImageURI has transfer protocol in it 240 size_t separator = imageURI.find(":"); 241 if ((separator == std::string::npos) || 242 ((separator + 1) > imageURI.size())) 243 { 244 messages::actionParameterValueTypeError( 245 asyncResp->res, imageURI, "ImageURI", 246 "UpdateService.SimpleUpdate"); 247 BMCWEB_LOG_ERROR << "ImageURI missing transfer protocol: " 248 << imageURI; 249 return; 250 } 251 transferProtocol = imageURI.substr(0, separator); 252 // Ensure protocol is upper case for a common comparison path below 253 boost::to_upper(*transferProtocol); 254 BMCWEB_LOG_DEBUG << "Encoded transfer protocol " 255 << *transferProtocol; 256 257 // Adjust imageURI to not have the protocol on it for parsing 258 // below 259 // ex. tftp://1.1.1.1/myfile.bin -> 1.1.1.1/myfile.bin 260 imageURI = imageURI.substr(separator + 3); 261 BMCWEB_LOG_DEBUG << "Adjusted imageUri " << imageURI; 262 } 263 264 // OpenBMC currently only supports TFTP 265 if (*transferProtocol != "TFTP") 266 { 267 messages::actionParameterNotSupported(asyncResp->res, 268 "TransferProtocol", 269 "UpdateService.SimpleUpdate"); 270 BMCWEB_LOG_ERROR << "Request incorrect protocol parameter: " 271 << *transferProtocol; 272 return; 273 } 274 275 // Format should be <IP or Hostname>/<file> for imageURI 276 size_t separator = imageURI.find("/"); 277 if ((separator == std::string::npos) || 278 ((separator + 1) > imageURI.size())) 279 { 280 messages::actionParameterValueTypeError( 281 asyncResp->res, imageURI, "ImageURI", 282 "UpdateService.SimpleUpdate"); 283 BMCWEB_LOG_ERROR << "Invalid ImageURI: " << imageURI; 284 return; 285 } 286 287 std::string tftpServer = imageURI.substr(0, separator); 288 std::string fwFile = imageURI.substr(separator + 1); 289 BMCWEB_LOG_DEBUG << "Server: " << tftpServer + " File: " << fwFile; 290 291 // Setup callback for when new software detected 292 // Give TFTP 2 minutes to complete 293 monitorForSoftwareAvailable(nullptr, req, 120); 294 295 // TFTP can take up to 2 minutes depending on image size and 296 // connection speed. Return to caller as soon as the TFTP operation 297 // has been started. The callback above will ensure the activate 298 // is started once the download has completed 299 redfish::messages::success(asyncResp->res); 300 301 // Call TFTP service 302 crow::connections::systemBus->async_method_call( 303 [](const boost::system::error_code ec) { 304 if (ec) 305 { 306 // messages::internalError(asyncResp->res); 307 cleanUp(); 308 BMCWEB_LOG_DEBUG << "error_code = " << ec; 309 BMCWEB_LOG_DEBUG << "error msg = " << ec.message(); 310 } 311 else 312 { 313 BMCWEB_LOG_DEBUG << "Call to DownloaViaTFTP Success"; 314 } 315 }, 316 "xyz.openbmc_project.Software.Download", 317 "/xyz/openbmc_project/software", "xyz.openbmc_project.Common.TFTP", 318 "DownloadViaTFTP", fwFile, tftpServer); 319 320 BMCWEB_LOG_DEBUG << "Exit UpdateService.SimpleUpdate doPost"; 321 } 322 }; 323 324 class UpdateService : public Node 325 { 326 public: 327 UpdateService(CrowApp &app) : Node(app, "/redfish/v1/UpdateService/") 328 { 329 entityPrivileges = { 330 {boost::beast::http::verb::get, {{"Login"}}}, 331 {boost::beast::http::verb::head, {{"Login"}}}, 332 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, 333 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 334 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 335 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 336 } 337 338 private: 339 void doGet(crow::Response &res, const crow::Request &req, 340 const std::vector<std::string> ¶ms) override 341 { 342 res.jsonValue["@odata.type"] = "#UpdateService.v1_2_0.UpdateService"; 343 res.jsonValue["@odata.id"] = "/redfish/v1/UpdateService"; 344 res.jsonValue["@odata.context"] = 345 "/redfish/v1/$metadata#UpdateService.UpdateService"; 346 res.jsonValue["Id"] = "UpdateService"; 347 res.jsonValue["Description"] = "Service for Software Update"; 348 res.jsonValue["Name"] = "Update Service"; 349 res.jsonValue["HttpPushUri"] = "/redfish/v1/UpdateService"; 350 // UpdateService cannot be disabled 351 res.jsonValue["ServiceEnabled"] = true; 352 res.jsonValue["FirmwareInventory"] = { 353 {"@odata.id", "/redfish/v1/UpdateService/FirmwareInventory"}}; 354 #ifdef BMCWEB_INSECURE_ENABLE_REDFISH_FW_TFTP_UPDATE 355 // Update Actions object. 356 nlohmann::json &updateSvcSimpleUpdate = 357 res.jsonValue["Actions"]["#UpdateService.SimpleUpdate"]; 358 updateSvcSimpleUpdate["target"] = 359 "/redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate"; 360 updateSvcSimpleUpdate["TransferProtocol@Redfish.AllowableValues"] = { 361 "TFTP"}; 362 #endif 363 res.end(); 364 } 365 366 void doPatch(crow::Response &res, const crow::Request &req, 367 const std::vector<std::string> ¶ms) override 368 { 369 BMCWEB_LOG_DEBUG << "doPatch..."; 370 371 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 372 std::string applyTime; 373 374 if (!json_util::readJson(req, res, "ApplyTime", applyTime)) 375 { 376 return; 377 } 378 379 if ((applyTime == "Immediate") || (applyTime == "OnReset")) 380 { 381 std::string applyTimeNewVal; 382 if (applyTime == "Immediate") 383 { 384 applyTimeNewVal = "xyz.openbmc_project.Software.ApplyTime." 385 "RequestedApplyTimes.Immediate"; 386 } 387 else 388 { 389 applyTimeNewVal = "xyz.openbmc_project.Software.ApplyTime." 390 "RequestedApplyTimes.OnReset"; 391 } 392 393 // Set the requested image apply time value 394 crow::connections::systemBus->async_method_call( 395 [asyncResp](const boost::system::error_code ec) { 396 if (ec) 397 { 398 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec; 399 messages::internalError(asyncResp->res); 400 return; 401 } 402 messages::success(asyncResp->res); 403 }, 404 "xyz.openbmc_project.Settings", 405 "/xyz/openbmc_project/software/apply_time", 406 "org.freedesktop.DBus.Properties", "Set", 407 "xyz.openbmc_project.Software.ApplyTime", "RequestedApplyTime", 408 std::variant<std::string>{applyTimeNewVal}); 409 } 410 else 411 { 412 BMCWEB_LOG_INFO << "ApplyTime value is not in the list of " 413 "acceptable values"; 414 messages::propertyValueNotInList(asyncResp->res, applyTime, 415 "ApplyTime"); 416 } 417 } 418 419 void doPost(crow::Response &res, const crow::Request &req, 420 const std::vector<std::string> ¶ms) override 421 { 422 BMCWEB_LOG_DEBUG << "doPost..."; 423 424 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 425 426 // Setup callback for when new software detected 427 monitorForSoftwareAvailable(asyncResp, req); 428 429 std::string filepath( 430 "/tmp/images/" + 431 boost::uuids::to_string(boost::uuids::random_generator()())); 432 BMCWEB_LOG_DEBUG << "Writing file to " << filepath; 433 std::ofstream out(filepath, std::ofstream::out | std::ofstream::binary | 434 std::ofstream::trunc); 435 out << req.body; 436 out.close(); 437 BMCWEB_LOG_DEBUG << "file upload complete!!"; 438 } 439 }; 440 441 class SoftwareInventoryCollection : public Node 442 { 443 public: 444 template <typename CrowApp> 445 SoftwareInventoryCollection(CrowApp &app) : 446 Node(app, "/redfish/v1/UpdateService/FirmwareInventory/") 447 { 448 entityPrivileges = { 449 {boost::beast::http::verb::get, {{"Login"}}}, 450 {boost::beast::http::verb::head, {{"Login"}}}, 451 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, 452 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 453 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 454 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 455 } 456 457 private: 458 void doGet(crow::Response &res, const crow::Request &req, 459 const std::vector<std::string> ¶ms) override 460 { 461 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 462 res.jsonValue["@odata.type"] = 463 "#SoftwareInventoryCollection.SoftwareInventoryCollection"; 464 res.jsonValue["@odata.id"] = 465 "/redfish/v1/UpdateService/FirmwareInventory"; 466 res.jsonValue["@odata.context"] = 467 "/redfish/v1/" 468 "$metadata#SoftwareInventoryCollection.SoftwareInventoryCollection"; 469 res.jsonValue["Name"] = "Software Inventory Collection"; 470 471 crow::connections::systemBus->async_method_call( 472 [asyncResp]( 473 const boost::system::error_code ec, 474 const std::vector<std::pair< 475 std::string, std::vector<std::pair< 476 std::string, std::vector<std::string>>>>> 477 &subtree) { 478 if (ec) 479 { 480 messages::internalError(asyncResp->res); 481 return; 482 } 483 asyncResp->res.jsonValue["Members"] = nlohmann::json::array(); 484 asyncResp->res.jsonValue["Members@odata.count"] = 0; 485 486 for (auto &obj : subtree) 487 { 488 const std::vector< 489 std::pair<std::string, std::vector<std::string>>> 490 &connections = obj.second; 491 492 // if can't parse fw id then return 493 std::size_t idPos; 494 if ((idPos = obj.first.rfind("/")) == std::string::npos) 495 { 496 messages::internalError(asyncResp->res); 497 BMCWEB_LOG_DEBUG << "Can't parse firmware ID!!"; 498 return; 499 } 500 std::string swId = obj.first.substr(idPos + 1); 501 502 nlohmann::json &members = 503 asyncResp->res.jsonValue["Members"]; 504 members.push_back( 505 {{"@odata.id", "/redfish/v1/UpdateService/" 506 "FirmwareInventory/" + 507 swId}}); 508 asyncResp->res.jsonValue["Members@odata.count"] = 509 members.size(); 510 } 511 }, 512 "xyz.openbmc_project.ObjectMapper", 513 "/xyz/openbmc_project/object_mapper", 514 "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", int32_t(0), 515 std::array<const char *, 1>{ 516 "xyz.openbmc_project.Software.Version"}); 517 } 518 }; 519 520 class SoftwareInventory : public Node 521 { 522 public: 523 template <typename CrowApp> 524 SoftwareInventory(CrowApp &app) : 525 Node(app, "/redfish/v1/UpdateService/FirmwareInventory/<str>/", 526 std::string()) 527 { 528 entityPrivileges = { 529 {boost::beast::http::verb::get, {{"Login"}}}, 530 {boost::beast::http::verb::head, {{"Login"}}}, 531 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, 532 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 533 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 534 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 535 } 536 537 private: 538 /* Fill related item links (i.e. bmc, bios) in for inventory */ 539 static void getRelatedItems(std::shared_ptr<AsyncResp> aResp, 540 const std::string &purpose) 541 { 542 if (purpose == fw_util::bmcPurpose) 543 { 544 nlohmann::json &members = aResp->res.jsonValue["RelatedItem"]; 545 members.push_back({{"@odata.id", "/redfish/v1/Managers/bmc"}}); 546 aResp->res.jsonValue["Members@odata.count"] = members.size(); 547 } 548 else if (purpose == fw_util::biosPurpose) 549 { 550 // TODO(geissonator) Need BIOS schema support added for this 551 // to be valid 552 // nlohmann::json &members = aResp->res.jsonValue["RelatedItem"]; 553 // members.push_back( 554 // {{"@odata.id", "/redfish/v1/Systems/system/BIOS"}}); 555 // aResp->res.jsonValue["Members@odata.count"] = members.size(); 556 } 557 else 558 { 559 BMCWEB_LOG_ERROR << "Unknown software purpose " << purpose; 560 } 561 } 562 563 void doGet(crow::Response &res, const crow::Request &req, 564 const std::vector<std::string> ¶ms) override 565 { 566 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 567 568 if (params.size() != 1) 569 { 570 messages::internalError(res); 571 res.end(); 572 return; 573 } 574 575 std::shared_ptr<std::string> swId = 576 std::make_shared<std::string>(params[0]); 577 578 res.jsonValue["@odata.id"] = 579 "/redfish/v1/UpdateService/FirmwareInventory/" + *swId; 580 581 crow::connections::systemBus->async_method_call( 582 [asyncResp, swId]( 583 const boost::system::error_code ec, 584 const std::vector<std::pair< 585 std::string, std::vector<std::pair< 586 std::string, std::vector<std::string>>>>> 587 &subtree) { 588 BMCWEB_LOG_DEBUG << "doGet callback..."; 589 if (ec) 590 { 591 messages::internalError(asyncResp->res); 592 return; 593 } 594 595 // Ensure we find our input swId, otherwise return an error 596 bool found = false; 597 for (const std::pair< 598 std::string, 599 std::vector< 600 std::pair<std::string, std::vector<std::string>>>> 601 &obj : subtree) 602 { 603 if (boost::ends_with(obj.first, *swId) != true) 604 { 605 continue; 606 } 607 608 if (obj.second.size() < 1) 609 { 610 continue; 611 } 612 613 found = true; 614 fw_util::getFwStatus(asyncResp, swId, obj.second[0].first); 615 616 crow::connections::systemBus->async_method_call( 617 [asyncResp, 618 swId](const boost::system::error_code error_code, 619 const boost::container::flat_map< 620 std::string, VariantType> &propertiesList) { 621 if (error_code) 622 { 623 messages::internalError(asyncResp->res); 624 return; 625 } 626 boost::container::flat_map< 627 std::string, VariantType>::const_iterator it = 628 propertiesList.find("Purpose"); 629 if (it == propertiesList.end()) 630 { 631 BMCWEB_LOG_DEBUG 632 << "Can't find property \"Purpose\"!"; 633 messages::propertyMissing(asyncResp->res, 634 "Purpose"); 635 return; 636 } 637 const std::string *swInvPurpose = 638 std::get_if<std::string>(&it->second); 639 if (swInvPurpose == nullptr) 640 { 641 BMCWEB_LOG_DEBUG 642 << "wrong types for property\"Purpose\"!"; 643 messages::propertyValueTypeError(asyncResp->res, 644 "", "Purpose"); 645 return; 646 } 647 648 BMCWEB_LOG_DEBUG << "swInvPurpose = " 649 << *swInvPurpose; 650 it = propertiesList.find("Version"); 651 if (it == propertiesList.end()) 652 { 653 BMCWEB_LOG_DEBUG 654 << "Can't find property \"Version\"!"; 655 messages::propertyMissing(asyncResp->res, 656 "Version"); 657 return; 658 } 659 660 BMCWEB_LOG_DEBUG << "Version found!"; 661 662 const std::string *version = 663 std::get_if<std::string>(&it->second); 664 665 if (version == nullptr) 666 { 667 BMCWEB_LOG_DEBUG 668 << "Can't find property \"Version\"!"; 669 670 messages::propertyValueTypeError(asyncResp->res, 671 "", "Version"); 672 return; 673 } 674 asyncResp->res.jsonValue["Version"] = *version; 675 asyncResp->res.jsonValue["Id"] = *swId; 676 677 // swInvPurpose is of format: 678 // xyz.openbmc_project.Software.Version.VersionPurpose.ABC 679 // Translate this to "ABC image" 680 size_t endDesc = swInvPurpose->rfind("."); 681 if (endDesc == std::string::npos) 682 { 683 messages::internalError(asyncResp->res); 684 return; 685 } 686 endDesc++; 687 if (endDesc >= swInvPurpose->size()) 688 { 689 messages::internalError(asyncResp->res); 690 return; 691 } 692 693 std::string formatDesc = 694 swInvPurpose->substr(endDesc); 695 asyncResp->res.jsonValue["Description"] = 696 formatDesc + " image"; 697 getRelatedItems(asyncResp, *swInvPurpose); 698 }, 699 obj.second[0].first, obj.first, 700 "org.freedesktop.DBus.Properties", "GetAll", 701 "xyz.openbmc_project.Software.Version"); 702 } 703 if (!found) 704 { 705 BMCWEB_LOG_ERROR << "Input swID " + *swId + " not found!"; 706 messages::resourceMissingAtURI( 707 asyncResp->res, 708 "/redfish/v1/UpdateService/FirmwareInventory/" + *swId); 709 return; 710 } 711 asyncResp->res.jsonValue["@odata.type"] = 712 "#SoftwareInventory.v1_1_0.SoftwareInventory"; 713 asyncResp->res.jsonValue["@odata.context"] = 714 "/redfish/v1/$metadata#SoftwareInventory.SoftwareInventory"; 715 asyncResp->res.jsonValue["Name"] = "Software Inventory"; 716 asyncResp->res.jsonValue["Updateable"] = false; 717 asyncResp->res.jsonValue["Status"]["Health"] = "OK"; 718 asyncResp->res.jsonValue["Status"]["HealthRollup"] = "OK"; 719 }, 720 "xyz.openbmc_project.ObjectMapper", 721 "/xyz/openbmc_project/object_mapper", 722 "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", int32_t(0), 723 std::array<const char *, 1>{ 724 "xyz.openbmc_project.Software.Version"}); 725 } 726 }; 727 728 } // namespace redfish 729