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 "bmcweb_config.h" 19 20 #include <app.hpp> 21 #include <boost/container/flat_map.hpp> 22 #include <registries/privilege_registry.hpp> 23 #include <utils/fw_utils.hpp> 24 25 #include <variant> 26 27 namespace redfish 28 { 29 30 // Match signals added on software path 31 static std::unique_ptr<sdbusplus::bus::match::match> fwUpdateMatcher; 32 static std::unique_ptr<sdbusplus::bus::match::match> fwUpdateErrorMatcher; 33 // Only allow one update at a time 34 static bool fwUpdateInProgress = false; 35 // Timer for software available 36 static std::unique_ptr<boost::asio::steady_timer> fwAvailableTimer; 37 38 inline static void cleanUp() 39 { 40 fwUpdateInProgress = false; 41 fwUpdateMatcher = nullptr; 42 fwUpdateErrorMatcher = nullptr; 43 } 44 inline static void activateImage(const std::string& objPath, 45 const std::string& service) 46 { 47 BMCWEB_LOG_DEBUG << "Activate image for " << objPath << " " << service; 48 crow::connections::systemBus->async_method_call( 49 [](const boost::system::error_code errorCode) { 50 if (errorCode) 51 { 52 BMCWEB_LOG_DEBUG << "error_code = " << errorCode; 53 BMCWEB_LOG_DEBUG << "error msg = " << errorCode.message(); 54 } 55 }, 56 service, objPath, "org.freedesktop.DBus.Properties", "Set", 57 "xyz.openbmc_project.Software.Activation", "RequestedActivation", 58 std::variant<std::string>( 59 "xyz.openbmc_project.Software.Activation.RequestedActivations.Active")); 60 } 61 62 // Note that asyncResp can be either a valid pointer or nullptr. If nullptr 63 // then no asyncResp updates will occur 64 static void 65 softwareInterfaceAdded(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, 66 sdbusplus::message::message& m, 67 task::Payload&& payload) 68 { 69 std::vector<std::pair< 70 std::string, 71 std::vector<std::pair<std::string, std::variant<std::string>>>>> 72 interfacesProperties; 73 74 sdbusplus::message::object_path objPath; 75 76 m.read(objPath, interfacesProperties); 77 78 BMCWEB_LOG_DEBUG << "obj path = " << objPath.str; 79 for (auto& interface : interfacesProperties) 80 { 81 BMCWEB_LOG_DEBUG << "interface = " << interface.first; 82 83 if (interface.first == "xyz.openbmc_project.Software.Activation") 84 { 85 // Retrieve service and activate 86 crow::connections::systemBus->async_method_call( 87 [objPath, asyncResp, payload(std::move(payload))]( 88 const boost::system::error_code errorCode, 89 const std::vector< 90 std::pair<std::string, std::vector<std::string>>>& 91 objInfo) mutable { 92 if (errorCode) 93 { 94 BMCWEB_LOG_DEBUG << "error_code = " << errorCode; 95 BMCWEB_LOG_DEBUG << "error msg = " 96 << errorCode.message(); 97 if (asyncResp) 98 { 99 messages::internalError(asyncResp->res); 100 } 101 cleanUp(); 102 return; 103 } 104 // Ensure we only got one service back 105 if (objInfo.size() != 1) 106 { 107 BMCWEB_LOG_ERROR << "Invalid Object Size " 108 << objInfo.size(); 109 if (asyncResp) 110 { 111 messages::internalError(asyncResp->res); 112 } 113 cleanUp(); 114 return; 115 } 116 // cancel timer only when 117 // xyz.openbmc_project.Software.Activation interface 118 // is added 119 fwAvailableTimer = nullptr; 120 121 activateImage(objPath.str, objInfo[0].first); 122 if (asyncResp) 123 { 124 std::shared_ptr<task::TaskData> task = 125 task::TaskData::createTask( 126 [](boost::system::error_code ec, 127 sdbusplus::message::message& msg, 128 const std::shared_ptr<task::TaskData>& 129 taskData) { 130 if (ec) 131 { 132 return task::completed; 133 } 134 135 std::string iface; 136 boost::container::flat_map< 137 std::string, 138 std::variant<std::string, uint8_t>> 139 values; 140 141 std::string index = 142 std::to_string(taskData->index); 143 msg.read(iface, values); 144 145 if (iface == 146 "xyz.openbmc_project.Software.Activation") 147 { 148 auto findActivation = 149 values.find("Activation"); 150 if (findActivation == values.end()) 151 { 152 return !task::completed; 153 } 154 std::string* state = 155 std::get_if<std::string>( 156 &(findActivation->second)); 157 158 if (state == nullptr) 159 { 160 taskData->messages.emplace_back( 161 messages::internalError()); 162 return task::completed; 163 } 164 165 if (boost::ends_with(*state, 166 "Invalid") || 167 boost::ends_with(*state, "Failed")) 168 { 169 taskData->state = "Exception"; 170 taskData->status = "Warning"; 171 taskData->messages.emplace_back( 172 messages::taskAborted(index)); 173 return task::completed; 174 } 175 176 if (boost::ends_with(*state, "Staged")) 177 { 178 taskData->state = "Stopping"; 179 taskData->messages.emplace_back( 180 messages::taskPaused(index)); 181 182 // its staged, set a long timer to 183 // allow them time to complete the 184 // update (probably cycle the 185 // system) if this expires then 186 // task will be cancelled 187 taskData->extendTimer( 188 std::chrono::hours(5)); 189 return !task::completed; 190 } 191 192 if (boost::ends_with(*state, "Active")) 193 { 194 taskData->messages.emplace_back( 195 messages::taskCompletedOK( 196 index)); 197 taskData->state = "Completed"; 198 return task::completed; 199 } 200 } 201 else if ( 202 iface == 203 "xyz.openbmc_project.Software.ActivationProgress") 204 { 205 auto findProgress = 206 values.find("Progress"); 207 if (findProgress == values.end()) 208 { 209 return !task::completed; 210 } 211 uint8_t* progress = 212 std::get_if<uint8_t>( 213 &(findProgress->second)); 214 215 if (progress == nullptr) 216 { 217 taskData->messages.emplace_back( 218 messages::internalError()); 219 return task::completed; 220 } 221 taskData->percentComplete = 222 static_cast<int>(*progress); 223 taskData->messages.emplace_back( 224 messages::taskProgressChanged( 225 index, static_cast<size_t>( 226 *progress))); 227 228 // if we're getting status updates it's 229 // still alive, update timer 230 taskData->extendTimer( 231 std::chrono::minutes(5)); 232 } 233 234 // as firmware update often results in a 235 // reboot, the task may never "complete" 236 // unless it is an error 237 238 return !task::completed; 239 }, 240 "type='signal',interface='org.freedesktop.DBus.Properties'," 241 "member='PropertiesChanged',path='" + 242 objPath.str + "'"); 243 task->startTimer(std::chrono::minutes(5)); 244 task->populateResp(asyncResp->res); 245 task->payload.emplace(std::move(payload)); 246 } 247 fwUpdateInProgress = false; 248 }, 249 "xyz.openbmc_project.ObjectMapper", 250 "/xyz/openbmc_project/object_mapper", 251 "xyz.openbmc_project.ObjectMapper", "GetObject", objPath.str, 252 std::array<const char*, 1>{ 253 "xyz.openbmc_project.Software.Activation"}); 254 } 255 } 256 } 257 258 // Note that asyncResp can be either a valid pointer or nullptr. If nullptr 259 // then no asyncResp updates will occur 260 static void monitorForSoftwareAvailable( 261 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, 262 const crow::Request& req, const std::string& url, 263 int timeoutTimeSeconds = 10) 264 { 265 // Only allow one FW update at a time 266 if (fwUpdateInProgress != false) 267 { 268 if (asyncResp) 269 { 270 messages::serviceTemporarilyUnavailable(asyncResp->res, "30"); 271 } 272 return; 273 } 274 275 fwAvailableTimer = 276 std::make_unique<boost::asio::steady_timer>(*req.ioService); 277 278 fwAvailableTimer->expires_after(std::chrono::seconds(timeoutTimeSeconds)); 279 280 fwAvailableTimer->async_wait( 281 [asyncResp](const boost::system::error_code& ec) { 282 cleanUp(); 283 if (ec == boost::asio::error::operation_aborted) 284 { 285 // expected, we were canceled before the timer completed. 286 return; 287 } 288 BMCWEB_LOG_ERROR 289 << "Timed out waiting for firmware object being created"; 290 BMCWEB_LOG_ERROR 291 << "FW image may has already been uploaded to server"; 292 if (ec) 293 { 294 BMCWEB_LOG_ERROR << "Async_wait failed" << ec; 295 return; 296 } 297 if (asyncResp) 298 { 299 redfish::messages::internalError(asyncResp->res); 300 } 301 }); 302 task::Payload payload(req); 303 auto callback = [asyncResp, 304 payload](sdbusplus::message::message& m) mutable { 305 BMCWEB_LOG_DEBUG << "Match fired"; 306 softwareInterfaceAdded(asyncResp, m, std::move(payload)); 307 }; 308 309 fwUpdateInProgress = true; 310 311 fwUpdateMatcher = std::make_unique<sdbusplus::bus::match::match>( 312 *crow::connections::systemBus, 313 "interface='org.freedesktop.DBus.ObjectManager',type='signal'," 314 "member='InterfacesAdded',path='/xyz/openbmc_project/software'", 315 callback); 316 317 fwUpdateErrorMatcher = std::make_unique<sdbusplus::bus::match::match>( 318 *crow::connections::systemBus, 319 "type='signal',member='PropertiesChanged',path_namespace='/xyz/" 320 "openbmc_project/logging/entry'," 321 "arg0='xyz.openbmc_project.Logging.Entry'", 322 [asyncResp, url](sdbusplus::message::message& m) { 323 BMCWEB_LOG_DEBUG << "Error Match fired"; 324 boost::container::flat_map<std::string, std::variant<std::string>> 325 values; 326 std::string objName; 327 m.read(objName, values); 328 auto find = values.find("Message"); 329 if (find == values.end()) 330 { 331 return; 332 } 333 std::string* type = std::get_if<std::string>(&(find->second)); 334 if (type == nullptr) 335 { 336 return; // if this was our message, timeout will cover it 337 } 338 if (!boost::starts_with(*type, "xyz.openbmc_project.Software")) 339 { 340 return; 341 } 342 if (*type == 343 "xyz.openbmc_project.Software.Image.Error.UnTarFailure") 344 { 345 redfish::messages::invalidUpload(asyncResp->res, url, 346 "Invalid archive"); 347 } 348 else if ( 349 *type == 350 "xyz.openbmc_project.Software.Image.Error.ManifestFileFailure") 351 { 352 redfish::messages::invalidUpload(asyncResp->res, url, 353 "Invalid manifest"); 354 } 355 else if (*type == 356 "xyz.openbmc_project.Software.Image.Error.ImageFailure") 357 { 358 redfish::messages::invalidUpload(asyncResp->res, url, 359 "Invalid image format"); 360 } 361 else if (*type == 362 "xyz.openbmc_project.Software.Version.Error.AlreadyExists") 363 { 364 365 redfish::messages::invalidUpload( 366 asyncResp->res, url, "Image version already exists"); 367 368 redfish::messages::resourceAlreadyExists( 369 asyncResp->res, "UpdateService.v1_5_0.UpdateService", 370 "Version", "uploaded version"); 371 } 372 else if (*type == 373 "xyz.openbmc_project.Software.Image.Error.BusyFailure") 374 { 375 redfish::messages::resourceExhaustion(asyncResp->res, url); 376 } 377 else 378 { 379 redfish::messages::internalError(asyncResp->res); 380 } 381 fwAvailableTimer = nullptr; 382 }); 383 } 384 385 /** 386 * UpdateServiceActionsSimpleUpdate class supports handle POST method for 387 * SimpleUpdate action. 388 */ 389 inline void requestRoutesUpdateServiceActionsSimpleUpdate(App& app) 390 { 391 BMCWEB_ROUTE( 392 app, "/redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate/") 393 .privileges(redfish::privileges::postUpdateService) 394 .methods( 395 boost::beast::http::verb:: 396 post)([](const crow::Request& req, 397 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { 398 std::optional<std::string> transferProtocol; 399 std::string imageURI; 400 401 BMCWEB_LOG_DEBUG << "Enter UpdateService.SimpleUpdate doPost"; 402 403 // User can pass in both TransferProtocol and ImageURI parameters or 404 // they can pass in just the ImageURI with the transfer protocol 405 // embedded within it. 406 // 1) TransferProtocol:TFTP ImageURI:1.1.1.1/myfile.bin 407 // 2) ImageURI:tftp://1.1.1.1/myfile.bin 408 409 if (!json_util::readJson(req, asyncResp->res, "TransferProtocol", 410 transferProtocol, "ImageURI", imageURI)) 411 { 412 BMCWEB_LOG_DEBUG 413 << "Missing TransferProtocol or ImageURI parameter"; 414 return; 415 } 416 if (!transferProtocol) 417 { 418 // Must be option 2 419 // Verify ImageURI has transfer protocol in it 420 size_t separator = imageURI.find(':'); 421 if ((separator == std::string::npos) || 422 ((separator + 1) > imageURI.size())) 423 { 424 messages::actionParameterValueTypeError( 425 asyncResp->res, imageURI, "ImageURI", 426 "UpdateService.SimpleUpdate"); 427 BMCWEB_LOG_ERROR << "ImageURI missing transfer protocol: " 428 << imageURI; 429 return; 430 } 431 transferProtocol = imageURI.substr(0, separator); 432 // Ensure protocol is upper case for a common comparison path 433 // below 434 boost::to_upper(*transferProtocol); 435 BMCWEB_LOG_DEBUG << "Encoded transfer protocol " 436 << *transferProtocol; 437 438 // Adjust imageURI to not have the protocol on it for parsing 439 // below 440 // ex. tftp://1.1.1.1/myfile.bin -> 1.1.1.1/myfile.bin 441 imageURI = imageURI.substr(separator + 3); 442 BMCWEB_LOG_DEBUG << "Adjusted imageUri " << imageURI; 443 } 444 445 // OpenBMC currently only supports TFTP 446 if (*transferProtocol != "TFTP") 447 { 448 messages::actionParameterNotSupported( 449 asyncResp->res, "TransferProtocol", 450 "UpdateService.SimpleUpdate"); 451 BMCWEB_LOG_ERROR << "Request incorrect protocol parameter: " 452 << *transferProtocol; 453 return; 454 } 455 456 // Format should be <IP or Hostname>/<file> for imageURI 457 size_t separator = imageURI.find('/'); 458 if ((separator == std::string::npos) || 459 ((separator + 1) > imageURI.size())) 460 { 461 messages::actionParameterValueTypeError( 462 asyncResp->res, imageURI, "ImageURI", 463 "UpdateService.SimpleUpdate"); 464 BMCWEB_LOG_ERROR << "Invalid ImageURI: " << imageURI; 465 return; 466 } 467 468 std::string tftpServer = imageURI.substr(0, separator); 469 std::string fwFile = imageURI.substr(separator + 1); 470 BMCWEB_LOG_DEBUG << "Server: " << tftpServer + " File: " << fwFile; 471 472 // Setup callback for when new software detected 473 // Give TFTP 10 minutes to complete 474 monitorForSoftwareAvailable( 475 asyncResp, req, 476 "/redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate", 477 600); 478 479 // TFTP can take up to 10 minutes depending on image size and 480 // connection speed. Return to caller as soon as the TFTP operation 481 // has been started. The callback above will ensure the activate 482 // is started once the download has completed 483 redfish::messages::success(asyncResp->res); 484 485 // Call TFTP service 486 crow::connections::systemBus->async_method_call( 487 [](const boost::system::error_code ec) { 488 if (ec) 489 { 490 // messages::internalError(asyncResp->res); 491 cleanUp(); 492 BMCWEB_LOG_DEBUG << "error_code = " << ec; 493 BMCWEB_LOG_DEBUG << "error msg = " << ec.message(); 494 } 495 else 496 { 497 BMCWEB_LOG_DEBUG << "Call to DownloaViaTFTP Success"; 498 } 499 }, 500 "xyz.openbmc_project.Software.Download", 501 "/xyz/openbmc_project/software", 502 "xyz.openbmc_project.Common.TFTP", "DownloadViaTFTP", fwFile, 503 tftpServer); 504 505 BMCWEB_LOG_DEBUG << "Exit UpdateService.SimpleUpdate doPost"; 506 }); 507 } 508 509 inline void requestRoutesUpdateService(App& app) 510 { 511 BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/") 512 .privileges(redfish::privileges::getUpdateService) 513 .methods( 514 boost::beast::http::verb:: 515 get)([](const crow::Request&, 516 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { 517 asyncResp->res.jsonValue["@odata.type"] = 518 "#UpdateService.v1_5_0.UpdateService"; 519 asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/UpdateService"; 520 asyncResp->res.jsonValue["Id"] = "UpdateService"; 521 asyncResp->res.jsonValue["Description"] = 522 "Service for Software Update"; 523 asyncResp->res.jsonValue["Name"] = "Update Service"; 524 asyncResp->res.jsonValue["HttpPushUri"] = 525 "/redfish/v1/UpdateService"; 526 // UpdateService cannot be disabled 527 asyncResp->res.jsonValue["ServiceEnabled"] = true; 528 asyncResp->res.jsonValue["FirmwareInventory"] = { 529 {"@odata.id", "/redfish/v1/UpdateService/FirmwareInventory"}}; 530 // Get the MaxImageSizeBytes 531 asyncResp->res.jsonValue["MaxImageSizeBytes"] = 532 bmcwebHttpReqBodyLimitMb * 1024 * 1024; 533 534 #ifdef BMCWEB_INSECURE_ENABLE_REDFISH_FW_TFTP_UPDATE 535 // Update Actions object. 536 nlohmann::json& updateSvcSimpleUpdate = 537 asyncResp->res 538 .jsonValue["Actions"]["#UpdateService.SimpleUpdate"]; 539 updateSvcSimpleUpdate["target"] = 540 "/redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate"; 541 updateSvcSimpleUpdate["TransferProtocol@Redfish.AllowableValues"] = 542 {"TFTP"}; 543 #endif 544 // Get the current ApplyTime value 545 crow::connections::systemBus->async_method_call( 546 [asyncResp](const boost::system::error_code ec, 547 const std::variant<std::string>& applyTime) { 548 if (ec) 549 { 550 BMCWEB_LOG_DEBUG << "DBUS response error " << ec; 551 messages::internalError(asyncResp->res); 552 return; 553 } 554 555 const std::string* s = std::get_if<std::string>(&applyTime); 556 if (s == nullptr) 557 { 558 return; 559 } 560 // Store the ApplyTime Value 561 if (*s == 562 "xyz.openbmc_project.Software.ApplyTime.RequestedApplyTimes.Immediate") 563 { 564 asyncResp->res 565 .jsonValue["HttpPushUriOptions"] 566 ["HttpPushUriApplyTime"]["ApplyTime"] = 567 "Immediate"; 568 } 569 else if ( 570 *s == 571 "xyz.openbmc_project.Software.ApplyTime.RequestedApplyTimes.OnReset") 572 { 573 asyncResp->res 574 .jsonValue["HttpPushUriOptions"] 575 ["HttpPushUriApplyTime"]["ApplyTime"] = 576 "OnReset"; 577 } 578 }, 579 "xyz.openbmc_project.Settings", 580 "/xyz/openbmc_project/software/apply_time", 581 "org.freedesktop.DBus.Properties", "Get", 582 "xyz.openbmc_project.Software.ApplyTime", "RequestedApplyTime"); 583 }); 584 BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/") 585 .privileges(redfish::privileges::patchUpdateService) 586 .methods( 587 boost::beast::http::verb:: 588 patch)([](const crow::Request& req, 589 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { 590 BMCWEB_LOG_DEBUG << "doPatch..."; 591 592 std::optional<nlohmann::json> pushUriOptions; 593 if (!json_util::readJson(req, asyncResp->res, "HttpPushUriOptions", 594 pushUriOptions)) 595 { 596 return; 597 } 598 599 if (pushUriOptions) 600 { 601 std::optional<nlohmann::json> pushUriApplyTime; 602 if (!json_util::readJson(*pushUriOptions, asyncResp->res, 603 "HttpPushUriApplyTime", 604 pushUriApplyTime)) 605 { 606 return; 607 } 608 609 if (pushUriApplyTime) 610 { 611 std::optional<std::string> applyTime; 612 if (!json_util::readJson(*pushUriApplyTime, asyncResp->res, 613 "ApplyTime", applyTime)) 614 { 615 return; 616 } 617 618 if (applyTime) 619 { 620 std::string applyTimeNewVal; 621 if (applyTime == "Immediate") 622 { 623 applyTimeNewVal = 624 "xyz.openbmc_project.Software.ApplyTime.RequestedApplyTimes.Immediate"; 625 } 626 else if (applyTime == "OnReset") 627 { 628 applyTimeNewVal = 629 "xyz.openbmc_project.Software.ApplyTime.RequestedApplyTimes.OnReset"; 630 } 631 else 632 { 633 BMCWEB_LOG_INFO 634 << "ApplyTime value is not in the list of acceptable values"; 635 messages::propertyValueNotInList( 636 asyncResp->res, *applyTime, "ApplyTime"); 637 return; 638 } 639 640 // Set the requested image apply time value 641 crow::connections::systemBus->async_method_call( 642 [asyncResp](const boost::system::error_code ec) { 643 if (ec) 644 { 645 BMCWEB_LOG_ERROR 646 << "D-Bus responses error: " << ec; 647 messages::internalError(asyncResp->res); 648 return; 649 } 650 messages::success(asyncResp->res); 651 }, 652 "xyz.openbmc_project.Settings", 653 "/xyz/openbmc_project/software/apply_time", 654 "org.freedesktop.DBus.Properties", "Set", 655 "xyz.openbmc_project.Software.ApplyTime", 656 "RequestedApplyTime", 657 std::variant<std::string>{applyTimeNewVal}); 658 } 659 } 660 } 661 }); 662 BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/") 663 .privileges(redfish::privileges::postUpdateService) 664 .methods(boost::beast::http::verb::post)( 665 [](const crow::Request& req, 666 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { 667 BMCWEB_LOG_DEBUG << "doPost..."; 668 669 // Setup callback for when new software detected 670 monitorForSoftwareAvailable(asyncResp, req, 671 "/redfish/v1/UpdateService"); 672 673 std::string filepath("/tmp/images/" + 674 boost::uuids::to_string( 675 boost::uuids::random_generator()())); 676 BMCWEB_LOG_DEBUG << "Writing file to " << filepath; 677 std::ofstream out(filepath, std::ofstream::out | 678 std::ofstream::binary | 679 std::ofstream::trunc); 680 out << req.body; 681 out.close(); 682 BMCWEB_LOG_DEBUG << "file upload complete!!"; 683 }); 684 } 685 686 inline void requestRoutesSoftwareInventoryCollection(App& app) 687 { 688 BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/FirmwareInventory/") 689 .privileges(redfish::privileges::getSoftwareInventoryCollection) 690 .methods( 691 boost::beast::http::verb:: 692 get)([](const crow::Request&, 693 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { 694 asyncResp->res.jsonValue["@odata.type"] = 695 "#SoftwareInventoryCollection.SoftwareInventoryCollection"; 696 asyncResp->res.jsonValue["@odata.id"] = 697 "/redfish/v1/UpdateService/FirmwareInventory"; 698 asyncResp->res.jsonValue["Name"] = "Software Inventory Collection"; 699 700 crow::connections::systemBus->async_method_call( 701 [asyncResp]( 702 const boost::system::error_code ec, 703 const std::vector< 704 std::pair<std::string, 705 std::vector<std::pair< 706 std::string, std::vector<std::string>>>>>& 707 subtree) { 708 if (ec) 709 { 710 messages::internalError(asyncResp->res); 711 return; 712 } 713 asyncResp->res.jsonValue["Members"] = 714 nlohmann::json::array(); 715 asyncResp->res.jsonValue["Members@odata.count"] = 0; 716 717 for (auto& obj : subtree) 718 { 719 sdbusplus::message::object_path path(obj.first); 720 std::string swId = path.filename(); 721 if (swId.empty()) 722 { 723 messages::internalError(asyncResp->res); 724 BMCWEB_LOG_DEBUG << "Can't parse firmware ID!!"; 725 return; 726 } 727 728 nlohmann::json& members = 729 asyncResp->res.jsonValue["Members"]; 730 members.push_back( 731 {{"@odata.id", 732 "/redfish/v1/UpdateService/FirmwareInventory/" + 733 swId}}); 734 asyncResp->res.jsonValue["Members@odata.count"] = 735 members.size(); 736 } 737 }, 738 // Note that only firmware levels associated with a device 739 // are stored under /xyz/openbmc_project/software therefore 740 // to ensure only real FirmwareInventory items are returned, 741 // this full object path must be used here as input to 742 // mapper 743 "xyz.openbmc_project.ObjectMapper", 744 "/xyz/openbmc_project/object_mapper", 745 "xyz.openbmc_project.ObjectMapper", "GetSubTree", 746 "/xyz/openbmc_project/software", static_cast<int32_t>(0), 747 std::array<const char*, 1>{ 748 "xyz.openbmc_project.Software.Version"}); 749 }); 750 } 751 /* Fill related item links (i.e. bmc, bios) in for inventory */ 752 inline static void 753 getRelatedItems(const std::shared_ptr<bmcweb::AsyncResp>& aResp, 754 const std::string& purpose) 755 { 756 if (purpose == fw_util::bmcPurpose) 757 { 758 nlohmann::json& relatedItem = aResp->res.jsonValue["RelatedItem"]; 759 relatedItem.push_back({{"@odata.id", "/redfish/v1/Managers/bmc"}}); 760 aResp->res.jsonValue["RelatedItem@odata.count"] = relatedItem.size(); 761 } 762 else if (purpose == fw_util::biosPurpose) 763 { 764 nlohmann::json& relatedItem = aResp->res.jsonValue["RelatedItem"]; 765 relatedItem.push_back( 766 {{"@odata.id", "/redfish/v1/Systems/system/Bios"}}); 767 aResp->res.jsonValue["Members@odata.count"] = relatedItem.size(); 768 } 769 else 770 { 771 BMCWEB_LOG_ERROR << "Unknown software purpose " << purpose; 772 } 773 } 774 775 inline void requestRoutesSoftwareInventory(App& app) 776 { 777 BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/FirmwareInventory/<str>/") 778 .privileges(redfish::privileges::getSoftwareInventory) 779 .methods( 780 boost::beast::http::verb::get)([](const crow::Request&, 781 const std::shared_ptr< 782 bmcweb::AsyncResp>& asyncResp, 783 const std::string& param) { 784 std::shared_ptr<std::string> swId = 785 std::make_shared<std::string>(param); 786 787 asyncResp->res.jsonValue["@odata.id"] = 788 "/redfish/v1/UpdateService/FirmwareInventory/" + *swId; 789 790 crow::connections::systemBus->async_method_call( 791 [asyncResp, swId]( 792 const boost::system::error_code ec, 793 const std::vector< 794 std::pair<std::string, 795 std::vector<std::pair< 796 std::string, std::vector<std::string>>>>>& 797 subtree) { 798 BMCWEB_LOG_DEBUG << "doGet callback..."; 799 if (ec) 800 { 801 messages::internalError(asyncResp->res); 802 return; 803 } 804 805 // Ensure we find our input swId, otherwise return an error 806 bool found = false; 807 for (const std::pair< 808 std::string, 809 std::vector<std::pair< 810 std::string, std::vector<std::string>>>>& obj : 811 subtree) 812 { 813 if (boost::ends_with(obj.first, *swId) != true) 814 { 815 continue; 816 } 817 818 if (obj.second.size() < 1) 819 { 820 continue; 821 } 822 823 found = true; 824 fw_util::getFwStatus(asyncResp, swId, 825 obj.second[0].first); 826 827 crow::connections::systemBus->async_method_call( 828 [asyncResp, swId]( 829 const boost::system::error_code errorCode, 830 const boost::container::flat_map< 831 std::string, VariantType>& propertiesList) { 832 if (errorCode) 833 { 834 messages::internalError(asyncResp->res); 835 return; 836 } 837 boost::container::flat_map< 838 std::string, VariantType>::const_iterator 839 it = propertiesList.find("Purpose"); 840 if (it == propertiesList.end()) 841 { 842 BMCWEB_LOG_DEBUG 843 << "Can't find property \"Purpose\"!"; 844 messages::propertyMissing(asyncResp->res, 845 "Purpose"); 846 return; 847 } 848 const std::string* swInvPurpose = 849 std::get_if<std::string>(&it->second); 850 if (swInvPurpose == nullptr) 851 { 852 BMCWEB_LOG_DEBUG 853 << "wrong types for property\"Purpose\"!"; 854 messages::propertyValueTypeError( 855 asyncResp->res, "", "Purpose"); 856 return; 857 } 858 859 BMCWEB_LOG_DEBUG << "swInvPurpose = " 860 << *swInvPurpose; 861 it = propertiesList.find("Version"); 862 if (it == propertiesList.end()) 863 { 864 BMCWEB_LOG_DEBUG 865 << "Can't find property \"Version\"!"; 866 messages::propertyMissing(asyncResp->res, 867 "Version"); 868 return; 869 } 870 871 BMCWEB_LOG_DEBUG << "Version found!"; 872 873 const std::string* version = 874 std::get_if<std::string>(&it->second); 875 876 if (version == nullptr) 877 { 878 BMCWEB_LOG_DEBUG 879 << "Can't find property \"Version\"!"; 880 881 messages::propertyValueTypeError( 882 asyncResp->res, "", "Version"); 883 return; 884 } 885 asyncResp->res.jsonValue["Version"] = *version; 886 asyncResp->res.jsonValue["Id"] = *swId; 887 888 // swInvPurpose is of format: 889 // xyz.openbmc_project.Software.Version.VersionPurpose.ABC 890 // Translate this to "ABC image" 891 size_t endDesc = swInvPurpose->rfind('.'); 892 if (endDesc == std::string::npos) 893 { 894 messages::internalError(asyncResp->res); 895 return; 896 } 897 endDesc++; 898 if (endDesc >= swInvPurpose->size()) 899 { 900 messages::internalError(asyncResp->res); 901 return; 902 } 903 904 std::string formatDesc = 905 swInvPurpose->substr(endDesc); 906 asyncResp->res.jsonValue["Description"] = 907 formatDesc + " image"; 908 getRelatedItems(asyncResp, *swInvPurpose); 909 }, 910 obj.second[0].first, obj.first, 911 "org.freedesktop.DBus.Properties", "GetAll", 912 "xyz.openbmc_project.Software.Version"); 913 } 914 if (!found) 915 { 916 BMCWEB_LOG_ERROR 917 << "Input swID " + *swId + " not found!"; 918 messages::resourceMissingAtURI( 919 asyncResp->res, 920 "/redfish/v1/UpdateService/FirmwareInventory/" + 921 *swId); 922 return; 923 } 924 asyncResp->res.jsonValue["@odata.type"] = 925 "#SoftwareInventory.v1_1_0.SoftwareInventory"; 926 asyncResp->res.jsonValue["Name"] = "Software Inventory"; 927 asyncResp->res.jsonValue["Status"]["HealthRollup"] = "OK"; 928 929 asyncResp->res.jsonValue["Updateable"] = false; 930 fw_util::getFwUpdateableStatus(asyncResp, swId); 931 }, 932 "xyz.openbmc_project.ObjectMapper", 933 "/xyz/openbmc_project/object_mapper", 934 "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", 935 static_cast<int32_t>(0), 936 std::array<const char*, 1>{ 937 "xyz.openbmc_project.Software.Version"}); 938 }); 939 } 940 941 } // namespace redfish 942