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