| /* |
| // Copyright (c) 2018 Intel Corporation |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| */ |
| #pragma once |
| |
| #include "bmcweb_config.h" |
| |
| #include "app.hpp" |
| #include "dbus_utility.hpp" |
| #include "multipart_parser.hpp" |
| #include "ossl_random.hpp" |
| #include "query.hpp" |
| #include "registries/privilege_registry.hpp" |
| #include "task.hpp" |
| #include "utils/collection.hpp" |
| #include "utils/dbus_utils.hpp" |
| #include "utils/sw_utils.hpp" |
| |
| #include <boost/system/error_code.hpp> |
| #include <boost/url/format.hpp> |
| #include <sdbusplus/asio/property.hpp> |
| #include <sdbusplus/bus/match.hpp> |
| #include <sdbusplus/unpack_properties.hpp> |
| |
| #include <array> |
| #include <filesystem> |
| #include <optional> |
| #include <string> |
| #include <string_view> |
| |
| namespace redfish |
| { |
| |
| // Match signals added on software path |
| // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) |
| static std::unique_ptr<sdbusplus::bus::match_t> fwUpdateMatcher; |
| // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) |
| static std::unique_ptr<sdbusplus::bus::match_t> fwUpdateErrorMatcher; |
| // Only allow one update at a time |
| // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) |
| static bool fwUpdateInProgress = false; |
| // Timer for software available |
| // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) |
| static std::unique_ptr<boost::asio::steady_timer> fwAvailableTimer; |
| |
| inline void cleanUp() |
| { |
| fwUpdateInProgress = false; |
| fwUpdateMatcher = nullptr; |
| fwUpdateErrorMatcher = nullptr; |
| } |
| |
| inline void activateImage(const std::string& objPath, |
| const std::string& service) |
| { |
| BMCWEB_LOG_DEBUG("Activate image for {} {}", objPath, service); |
| sdbusplus::asio::setProperty( |
| *crow::connections::systemBus, service, objPath, |
| "xyz.openbmc_project.Software.Activation", "RequestedActivation", |
| "xyz.openbmc_project.Software.Activation.RequestedActivations.Active", |
| [](const boost::system::error_code& ec) { |
| if (ec) |
| { |
| BMCWEB_LOG_DEBUG("error_code = {}", ec); |
| BMCWEB_LOG_DEBUG("error msg = {}", ec.message()); |
| } |
| }); |
| } |
| |
| // Note that asyncResp can be either a valid pointer or nullptr. If nullptr |
| // then no asyncResp updates will occur |
| static void |
| softwareInterfaceAdded(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| sdbusplus::message_t& m, task::Payload&& payload) |
| { |
| dbus::utility::DBusInterfacesMap interfacesProperties; |
| |
| sdbusplus::message::object_path objPath; |
| |
| m.read(objPath, interfacesProperties); |
| |
| BMCWEB_LOG_DEBUG("obj path = {}", objPath.str); |
| for (const auto& interface : interfacesProperties) |
| { |
| BMCWEB_LOG_DEBUG("interface = {}", interface.first); |
| |
| if (interface.first == "xyz.openbmc_project.Software.Activation") |
| { |
| // Retrieve service and activate |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.Software.Activation"}; |
| dbus::utility::getDbusObject( |
| objPath.str, interfaces, |
| [objPath, asyncResp, payload(std::move(payload))]( |
| const boost::system::error_code& ec, |
| const std::vector< |
| std::pair<std::string, std::vector<std::string>>>& |
| objInfo) mutable { |
| if (ec) |
| { |
| BMCWEB_LOG_DEBUG("error_code = {}", ec); |
| BMCWEB_LOG_DEBUG("error msg = {}", ec.message()); |
| if (asyncResp) |
| { |
| messages::internalError(asyncResp->res); |
| } |
| cleanUp(); |
| return; |
| } |
| // Ensure we only got one service back |
| if (objInfo.size() != 1) |
| { |
| BMCWEB_LOG_ERROR("Invalid Object Size {}", objInfo.size()); |
| if (asyncResp) |
| { |
| messages::internalError(asyncResp->res); |
| } |
| cleanUp(); |
| return; |
| } |
| // cancel timer only when |
| // xyz.openbmc_project.Software.Activation interface |
| // is added |
| fwAvailableTimer = nullptr; |
| |
| activateImage(objPath.str, objInfo[0].first); |
| if (asyncResp) |
| { |
| std::shared_ptr<task::TaskData> task = |
| task::TaskData::createTask( |
| [](const boost::system::error_code& ec2, |
| sdbusplus::message_t& msg, |
| const std::shared_ptr<task::TaskData>& |
| taskData) { |
| if (ec2) |
| { |
| return task::completed; |
| } |
| |
| std::string iface; |
| dbus::utility::DBusPropertiesMap values; |
| |
| std::string index = std::to_string(taskData->index); |
| msg.read(iface, values); |
| |
| if (iface == "xyz.openbmc_project.Software.Activation") |
| { |
| const std::string* state = nullptr; |
| for (const auto& property : values) |
| { |
| if (property.first == "Activation") |
| { |
| state = std::get_if<std::string>( |
| &property.second); |
| if (state == nullptr) |
| { |
| taskData->messages.emplace_back( |
| messages::internalError()); |
| return task::completed; |
| } |
| } |
| } |
| |
| if (state == nullptr) |
| { |
| return !task::completed; |
| } |
| |
| if (state->ends_with("Invalid") || |
| state->ends_with("Failed")) |
| { |
| taskData->state = "Exception"; |
| taskData->status = "Warning"; |
| taskData->messages.emplace_back( |
| messages::taskAborted(index)); |
| return task::completed; |
| } |
| |
| if (state->ends_with("Staged")) |
| { |
| taskData->state = "Stopping"; |
| taskData->messages.emplace_back( |
| messages::taskPaused(index)); |
| |
| // its staged, set a long timer to |
| // allow them time to complete the |
| // update (probably cycle the |
| // system) if this expires then |
| // task will be canceled |
| taskData->extendTimer(std::chrono::hours(5)); |
| return !task::completed; |
| } |
| |
| if (state->ends_with("Active")) |
| { |
| taskData->messages.emplace_back( |
| messages::taskCompletedOK(index)); |
| taskData->state = "Completed"; |
| return task::completed; |
| } |
| } |
| else if ( |
| iface == |
| "xyz.openbmc_project.Software.ActivationProgress") |
| { |
| const uint8_t* progress = nullptr; |
| for (const auto& property : values) |
| { |
| if (property.first == "Progress") |
| { |
| progress = |
| std::get_if<uint8_t>(&property.second); |
| if (progress == nullptr) |
| { |
| taskData->messages.emplace_back( |
| messages::internalError()); |
| return task::completed; |
| } |
| } |
| } |
| |
| if (progress == nullptr) |
| { |
| return !task::completed; |
| } |
| taskData->percentComplete = *progress; |
| taskData->messages.emplace_back( |
| messages::taskProgressChanged(index, |
| *progress)); |
| |
| // if we're getting status updates it's |
| // still alive, update timer |
| taskData->extendTimer(std::chrono::minutes(5)); |
| } |
| |
| // as firmware update often results in a |
| // reboot, the task may never "complete" |
| // unless it is an error |
| |
| return !task::completed; |
| }, |
| "type='signal',interface='org.freedesktop.DBus.Properties'," |
| "member='PropertiesChanged',path='" + |
| objPath.str + "'"); |
| task->startTimer(std::chrono::minutes(5)); |
| task->populateResp(asyncResp->res); |
| task->payload.emplace(std::move(payload)); |
| } |
| fwUpdateInProgress = false; |
| }); |
| |
| break; |
| } |
| } |
| } |
| |
| inline void afterAvailbleTimerAsyncWait( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const boost::system::error_code& ec) |
| { |
| cleanUp(); |
| if (ec == boost::asio::error::operation_aborted) |
| { |
| // expected, we were canceled before the timer completed. |
| return; |
| } |
| BMCWEB_LOG_ERROR("Timed out waiting for firmware object being created"); |
| BMCWEB_LOG_ERROR("FW image may has already been uploaded to server"); |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR("Async_wait failed{}", ec); |
| return; |
| } |
| if (asyncResp) |
| { |
| redfish::messages::internalError(asyncResp->res); |
| } |
| } |
| |
| inline void |
| handleUpdateErrorType(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& url, const std::string& type) |
| { |
| if (type == "xyz.openbmc_project.Software.Image.Error.UnTarFailure") |
| { |
| redfish::messages::invalidUpload(asyncResp->res, url, |
| "Invalid archive"); |
| } |
| else if (type == |
| "xyz.openbmc_project.Software.Image.Error.ManifestFileFailure") |
| { |
| redfish::messages::invalidUpload(asyncResp->res, url, |
| "Invalid manifest"); |
| } |
| else if (type == "xyz.openbmc_project.Software.Image.Error.ImageFailure") |
| { |
| redfish::messages::invalidUpload(asyncResp->res, url, |
| "Invalid image format"); |
| } |
| else if (type == "xyz.openbmc_project.Software.Version.Error.AlreadyExists") |
| { |
| redfish::messages::invalidUpload(asyncResp->res, url, |
| "Image version already exists"); |
| |
| redfish::messages::resourceAlreadyExists( |
| asyncResp->res, "UpdateService", "Version", "uploaded version"); |
| } |
| else if (type == "xyz.openbmc_project.Software.Image.Error.BusyFailure") |
| { |
| redfish::messages::resourceExhaustion(asyncResp->res, url); |
| } |
| else if (type == "xyz.openbmc_project.Software.Version.Error.Incompatible") |
| { |
| redfish::messages::invalidUpload(asyncResp->res, url, |
| "Incompatible image version"); |
| } |
| else if (type == |
| "xyz.openbmc_project.Software.Version.Error.ExpiredAccessKey") |
| { |
| redfish::messages::invalidUpload(asyncResp->res, url, |
| "Update Access Key Expired"); |
| } |
| else if (type == |
| "xyz.openbmc_project.Software.Version.Error.InvalidSignature") |
| { |
| redfish::messages::invalidUpload(asyncResp->res, url, |
| "Invalid image signature"); |
| } |
| else if (type == |
| "xyz.openbmc_project.Software.Image.Error.InternalFailure" || |
| type == "xyz.openbmc_project.Software.Version.Error.HostFile") |
| { |
| BMCWEB_LOG_ERROR("Software Image Error type={}", type); |
| redfish::messages::internalError(asyncResp->res); |
| } |
| else |
| { |
| // Unrelated error types. Ignored |
| BMCWEB_LOG_INFO("Non-Software-related Error type={}. Ignored", type); |
| return; |
| } |
| // Clear the timer |
| fwAvailableTimer = nullptr; |
| } |
| |
| inline void |
| afterUpdateErrorMatcher(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& url, sdbusplus::message_t& m) |
| { |
| dbus::utility::DBusInterfacesMap interfacesProperties; |
| sdbusplus::message::object_path objPath; |
| m.read(objPath, interfacesProperties); |
| BMCWEB_LOG_DEBUG("obj path = {}", objPath.str); |
| for (const std::pair<std::string, dbus::utility::DBusPropertiesMap>& |
| interface : interfacesProperties) |
| { |
| if (interface.first == "xyz.openbmc_project.Logging.Entry") |
| { |
| for (const std::pair<std::string, dbus::utility::DbusVariantType>& |
| value : interface.second) |
| { |
| if (value.first != "Message") |
| { |
| continue; |
| } |
| const std::string* type = |
| std::get_if<std::string>(&value.second); |
| if (type == nullptr) |
| { |
| // if this was our message, timeout will cover it |
| return; |
| } |
| handleUpdateErrorType(asyncResp, url, *type); |
| } |
| } |
| } |
| } |
| |
| // Note that asyncResp can be either a valid pointer or nullptr. If nullptr |
| // then no asyncResp updates will occur |
| static void monitorForSoftwareAvailable( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const crow::Request& req, const std::string& url, |
| int timeoutTimeSeconds = 25) |
| { |
| // Only allow one FW update at a time |
| if (fwUpdateInProgress) |
| { |
| if (asyncResp) |
| { |
| messages::serviceTemporarilyUnavailable(asyncResp->res, "30"); |
| } |
| return; |
| } |
| |
| fwAvailableTimer = |
| std::make_unique<boost::asio::steady_timer>(*req.ioService); |
| |
| fwAvailableTimer->expires_after(std::chrono::seconds(timeoutTimeSeconds)); |
| |
| fwAvailableTimer->async_wait( |
| std::bind_front(afterAvailbleTimerAsyncWait, asyncResp)); |
| |
| task::Payload payload(req); |
| auto callback = [asyncResp, payload](sdbusplus::message_t& m) mutable { |
| BMCWEB_LOG_DEBUG("Match fired"); |
| softwareInterfaceAdded(asyncResp, m, std::move(payload)); |
| }; |
| |
| fwUpdateInProgress = true; |
| |
| fwUpdateMatcher = std::make_unique<sdbusplus::bus::match_t>( |
| *crow::connections::systemBus, |
| "interface='org.freedesktop.DBus.ObjectManager',type='signal'," |
| "member='InterfacesAdded',path='/xyz/openbmc_project/software'", |
| callback); |
| |
| fwUpdateErrorMatcher = std::make_unique<sdbusplus::bus::match_t>( |
| *crow::connections::systemBus, |
| "interface='org.freedesktop.DBus.ObjectManager',type='signal'," |
| "member='InterfacesAdded'," |
| "path='/xyz/openbmc_project/logging'", |
| std::bind_front(afterUpdateErrorMatcher, asyncResp, url)); |
| } |
| |
| struct TftpUrl |
| { |
| std::string fwFile; |
| std::string tftpServer; |
| }; |
| |
| inline std::optional<TftpUrl> |
| parseTftpUrl(std::string imageURI, |
| std::optional<std::string> transferProtocol, |
| crow::Response& res) |
| { |
| if (imageURI.find("://") == std::string::npos) |
| { |
| if (imageURI.starts_with("/")) |
| { |
| messages::actionParameterValueTypeError( |
| res, imageURI, "ImageURI", "UpdateService.SimpleUpdate"); |
| return std::nullopt; |
| } |
| if (!transferProtocol) |
| { |
| messages::actionParameterValueTypeError( |
| res, imageURI, "ImageURI", "UpdateService.SimpleUpdate"); |
| return std::nullopt; |
| } |
| // OpenBMC currently only supports TFTP |
| if (*transferProtocol != "TFTP") |
| { |
| messages::actionParameterNotSupported(res, "TransferProtocol", |
| *transferProtocol); |
| BMCWEB_LOG_ERROR("Request incorrect protocol parameter: {}", |
| *transferProtocol); |
| return std::nullopt; |
| } |
| imageURI = "tftp://" + imageURI; |
| } |
| |
| boost::system::result<boost::urls::url> url = |
| boost::urls::parse_absolute_uri(imageURI); |
| if (!url) |
| { |
| messages::actionParameterValueTypeError(res, imageURI, "ImageURI", |
| "UpdateService.SimpleUpdate"); |
| |
| return std::nullopt; |
| } |
| url->normalize(); |
| |
| if (url->scheme() != "tftp") |
| { |
| messages::actionParameterNotSupported(res, "ImageURI", imageURI); |
| return std::nullopt; |
| } |
| std::string path(url->encoded_path()); |
| if (path.size() < 2) |
| { |
| messages::actionParameterNotSupported(res, "ImageURI", imageURI); |
| return std::nullopt; |
| } |
| path.erase(0, 1); |
| std::string host(url->encoded_host_and_port()); |
| return TftpUrl{path, host}; |
| } |
| |
| /** |
| * UpdateServiceActionsSimpleUpdate class supports handle POST method for |
| * SimpleUpdate action. |
| */ |
| inline void requestRoutesUpdateServiceActionsSimpleUpdate(App& app) |
| { |
| BMCWEB_ROUTE( |
| app, "/redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate/") |
| .privileges(redfish::privileges::postUpdateService) |
| .methods(boost::beast::http::verb::post)( |
| [&app](const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| |
| std::optional<std::string> transferProtocol; |
| std::string imageURI; |
| |
| BMCWEB_LOG_DEBUG("Enter UpdateService.SimpleUpdate doPost"); |
| |
| // User can pass in both TransferProtocol and ImageURI parameters or |
| // they can pass in just the ImageURI with the transfer protocol |
| // embedded within it. |
| // 1) TransferProtocol:TFTP ImageURI:1.1.1.1/myfile.bin |
| // 2) ImageURI:tftp://1.1.1.1/myfile.bin |
| |
| if (!json_util::readJsonAction(req, asyncResp->res, "TransferProtocol", |
| transferProtocol, "ImageURI", imageURI)) |
| { |
| BMCWEB_LOG_DEBUG("Missing TransferProtocol or ImageURI parameter"); |
| return; |
| } |
| std::optional<TftpUrl> ret = parseTftpUrl(imageURI, transferProtocol, |
| asyncResp->res); |
| if (!ret) |
| { |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG("Server: {} File: {}", ret->tftpServer, ret->fwFile); |
| |
| // Setup callback for when new software detected |
| // Give TFTP 10 minutes to complete |
| monitorForSoftwareAvailable( |
| asyncResp, req, |
| "/redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate", |
| 600); |
| |
| // TFTP can take up to 10 minutes depending on image size and |
| // connection speed. Return to caller as soon as the TFTP operation |
| // has been started. The callback above will ensure the activate |
| // is started once the download has completed |
| redfish::messages::success(asyncResp->res); |
| |
| // Call TFTP service |
| crow::connections::systemBus->async_method_call( |
| [](const boost::system::error_code& ec) { |
| if (ec) |
| { |
| // messages::internalError(asyncResp->res); |
| cleanUp(); |
| BMCWEB_LOG_DEBUG("error_code = {}", ec); |
| BMCWEB_LOG_DEBUG("error msg = {}", ec.message()); |
| } |
| else |
| { |
| BMCWEB_LOG_DEBUG("Call to DownloaViaTFTP Success"); |
| } |
| }, |
| "xyz.openbmc_project.Software.Download", |
| "/xyz/openbmc_project/software", "xyz.openbmc_project.Common.TFTP", |
| "DownloadViaTFTP", ret->fwFile, ret->tftpServer); |
| |
| BMCWEB_LOG_DEBUG("Exit UpdateService.SimpleUpdate doPost"); |
| }); |
| } |
| |
| inline void uploadImageFile(crow::Response& res, std::string_view body) |
| { |
| std::filesystem::path filepath("/tmp/images/" + bmcweb::getRandomUUID()); |
| |
| BMCWEB_LOG_DEBUG("Writing file to {}", filepath.string()); |
| std::ofstream out(filepath, std::ofstream::out | std::ofstream::binary | |
| std::ofstream::trunc); |
| // set the permission of the file to 640 |
| std::filesystem::perms permission = std::filesystem::perms::owner_read | |
| std::filesystem::perms::group_read; |
| std::filesystem::permissions(filepath, permission); |
| out << body; |
| |
| if (out.bad()) |
| { |
| messages::internalError(res); |
| cleanUp(); |
| } |
| } |
| |
| inline void setApplyTime(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& applyTime) |
| { |
| std::string applyTimeNewVal; |
| if (applyTime == "Immediate") |
| { |
| applyTimeNewVal = |
| "xyz.openbmc_project.Software.ApplyTime.RequestedApplyTimes.Immediate"; |
| } |
| else if (applyTime == "OnReset") |
| { |
| applyTimeNewVal = |
| "xyz.openbmc_project.Software.ApplyTime.RequestedApplyTimes.OnReset"; |
| } |
| else |
| { |
| BMCWEB_LOG_INFO( |
| "ApplyTime value is not in the list of acceptable values"); |
| messages::propertyValueNotInList(asyncResp->res, applyTime, |
| "ApplyTime"); |
| return; |
| } |
| |
| setDbusProperty(asyncResp, "xyz.openbmc_project.Settings", |
| sdbusplus::message::object_path( |
| "/xyz/openbmc_project/software/apply_time"), |
| "xyz.openbmc_project.Software.ApplyTime", |
| "RequestedApplyTime", "ApplyTime", applyTimeNewVal); |
| } |
| |
| inline void |
| updateMultipartContext(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const MultipartParser& parser) |
| { |
| const std::string* uploadData = nullptr; |
| std::optional<std::string> applyTime = "OnReset"; |
| bool targetFound = false; |
| for (const FormPart& formpart : parser.mime_fields) |
| { |
| boost::beast::http::fields::const_iterator it = |
| formpart.fields.find("Content-Disposition"); |
| if (it == formpart.fields.end()) |
| { |
| BMCWEB_LOG_ERROR("Couldn't find Content-Disposition"); |
| return; |
| } |
| BMCWEB_LOG_INFO("Parsing value {}", it->value()); |
| |
| // The construction parameters of param_list must start with `;` |
| size_t index = it->value().find(';'); |
| if (index == std::string::npos) |
| { |
| continue; |
| } |
| |
| for (const auto& param : |
| boost::beast::http::param_list{it->value().substr(index)}) |
| { |
| if (param.first != "name" || param.second.empty()) |
| { |
| continue; |
| } |
| |
| if (param.second == "UpdateParameters") |
| { |
| std::vector<std::string> targets; |
| nlohmann::json content = |
| nlohmann::json::parse(formpart.content); |
| nlohmann::json::object_t* obj = |
| content.get_ptr<nlohmann::json::object_t*>(); |
| if (obj == nullptr) |
| { |
| messages::propertyValueFormatError(asyncResp->res, targets, |
| "UpdateParameters"); |
| return; |
| } |
| |
| if (!json_util::readJsonObject( |
| *obj, asyncResp->res, "Targets", targets, |
| "@Redfish.OperationApplyTime", applyTime)) |
| { |
| return; |
| } |
| if (targets.size() != 1) |
| { |
| messages::propertyValueFormatError(asyncResp->res, targets, |
| "Targets"); |
| return; |
| } |
| if (targets[0] != "/redfish/v1/Managers/bmc") |
| { |
| messages::propertyValueNotInList(asyncResp->res, targets[0], |
| "Targets/0"); |
| return; |
| } |
| targetFound = true; |
| } |
| else if (param.second == "UpdateFile") |
| { |
| uploadData = &(formpart.content); |
| } |
| } |
| } |
| |
| if (uploadData == nullptr) |
| { |
| BMCWEB_LOG_ERROR("Upload data is NULL"); |
| messages::propertyMissing(asyncResp->res, "UpdateFile"); |
| return; |
| } |
| if (!targetFound) |
| { |
| messages::propertyMissing(asyncResp->res, "targets"); |
| return; |
| } |
| |
| setApplyTime(asyncResp, *applyTime); |
| |
| uploadImageFile(asyncResp->res, *uploadData); |
| } |
| |
| inline void |
| handleUpdateServicePost(App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| std::string_view contentType = req.getHeaderValue("Content-Type"); |
| |
| BMCWEB_LOG_DEBUG("doPost: contentType={}", contentType); |
| |
| // Make sure that content type is application/octet-stream or |
| // multipart/form-data |
| if (bmcweb::asciiIEquals(contentType, "application/octet-stream")) |
| { |
| // Setup callback for when new software detected |
| monitorForSoftwareAvailable(asyncResp, req, |
| "/redfish/v1/UpdateService"); |
| |
| uploadImageFile(asyncResp->res, req.body()); |
| } |
| else if (contentType.starts_with("multipart/form-data")) |
| { |
| MultipartParser parser; |
| |
| // Setup callback for when new software detected |
| monitorForSoftwareAvailable(asyncResp, req, |
| "/redfish/v1/UpdateService"); |
| |
| ParserError ec = parser.parse(req); |
| if (ec != ParserError::PARSER_SUCCESS) |
| { |
| // handle error |
| BMCWEB_LOG_ERROR("MIME parse failed, ec : {}", |
| static_cast<int>(ec)); |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| updateMultipartContext(asyncResp, parser); |
| } |
| else |
| { |
| BMCWEB_LOG_DEBUG("Bad content type specified:{}", contentType); |
| asyncResp->res.result(boost::beast::http::status::bad_request); |
| } |
| } |
| |
| inline void requestRoutesUpdateService(App& app) |
| { |
| BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/") |
| .privileges(redfish::privileges::getUpdateService) |
| .methods(boost::beast::http::verb::get)( |
| [&app](const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| asyncResp->res.jsonValue["@odata.type"] = |
| "#UpdateService.v1_11_1.UpdateService"; |
| asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/UpdateService"; |
| asyncResp->res.jsonValue["Id"] = "UpdateService"; |
| asyncResp->res.jsonValue["Description"] = "Service for Software Update"; |
| asyncResp->res.jsonValue["Name"] = "Update Service"; |
| |
| asyncResp->res.jsonValue["HttpPushUri"] = |
| "/redfish/v1/UpdateService/update"; |
| asyncResp->res.jsonValue["MultipartHttpPushUri"] = |
| "/redfish/v1/UpdateService/update"; |
| |
| // UpdateService cannot be disabled |
| asyncResp->res.jsonValue["ServiceEnabled"] = true; |
| asyncResp->res.jsonValue["FirmwareInventory"]["@odata.id"] = |
| "/redfish/v1/UpdateService/FirmwareInventory"; |
| // Get the MaxImageSizeBytes |
| asyncResp->res.jsonValue["MaxImageSizeBytes"] = |
| bmcwebHttpReqBodyLimitMb * 1024 * 1024; |
| |
| #ifdef BMCWEB_INSECURE_ENABLE_REDFISH_FW_TFTP_UPDATE |
| // Update Actions object. |
| nlohmann::json& updateSvcSimpleUpdate = |
| asyncResp->res.jsonValue["Actions"]["#UpdateService.SimpleUpdate"]; |
| updateSvcSimpleUpdate["target"] = |
| "/redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate"; |
| updateSvcSimpleUpdate["TransferProtocol@Redfish.AllowableValues"] = { |
| "TFTP"}; |
| #endif |
| // Get the current ApplyTime value |
| sdbusplus::asio::getProperty<std::string>( |
| *crow::connections::systemBus, "xyz.openbmc_project.Settings", |
| "/xyz/openbmc_project/software/apply_time", |
| "xyz.openbmc_project.Software.ApplyTime", "RequestedApplyTime", |
| [asyncResp](const boost::system::error_code& ec, |
| const std::string& applyTime) { |
| if (ec) |
| { |
| BMCWEB_LOG_DEBUG("DBUS response error {}", ec); |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| // Store the ApplyTime Value |
| if (applyTime == "xyz.openbmc_project.Software.ApplyTime." |
| "RequestedApplyTimes.Immediate") |
| { |
| asyncResp->res.jsonValue["HttpPushUriOptions"] |
| ["HttpPushUriApplyTime"]["ApplyTime"] = |
| "Immediate"; |
| } |
| else if (applyTime == "xyz.openbmc_project.Software.ApplyTime." |
| "RequestedApplyTimes.OnReset") |
| { |
| asyncResp->res.jsonValue["HttpPushUriOptions"] |
| ["HttpPushUriApplyTime"]["ApplyTime"] = |
| "OnReset"; |
| } |
| }); |
| }); |
| BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/") |
| .privileges(redfish::privileges::patchUpdateService) |
| .methods(boost::beast::http::verb::patch)( |
| [&app](const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| BMCWEB_LOG_DEBUG("doPatch..."); |
| |
| std::optional<std::string> applyTime; |
| if (!json_util::readJsonPatch( |
| req, asyncResp->res, |
| "HttpPushUriOptions/HttpPushUriApplyTime/ApplyTime", applyTime)) |
| { |
| return; |
| } |
| |
| if (applyTime) |
| { |
| setApplyTime(asyncResp, *applyTime); |
| } |
| }); |
| |
| BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/update/") |
| .privileges(redfish::privileges::postUpdateService) |
| .methods(boost::beast::http::verb::post)( |
| std::bind_front(handleUpdateServicePost, std::ref(app))); |
| } |
| |
| inline void requestRoutesSoftwareInventoryCollection(App& app) |
| { |
| BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/FirmwareInventory/") |
| .privileges(redfish::privileges::getSoftwareInventoryCollection) |
| .methods(boost::beast::http::verb::get)( |
| [&app](const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| asyncResp->res.jsonValue["@odata.type"] = |
| "#SoftwareInventoryCollection.SoftwareInventoryCollection"; |
| asyncResp->res.jsonValue["@odata.id"] = |
| "/redfish/v1/UpdateService/FirmwareInventory"; |
| asyncResp->res.jsonValue["Name"] = "Software Inventory Collection"; |
| const std::array<const std::string_view, 1> iface = { |
| "xyz.openbmc_project.Software.Version"}; |
| |
| redfish::collection_util::getCollectionMembers( |
| asyncResp, |
| boost::urls::url("/redfish/v1/UpdateService/FirmwareInventory"), |
| iface, "/xyz/openbmc_project/software"); |
| }); |
| } |
| /* Fill related item links (i.e. bmc, bios) in for inventory */ |
| inline static void |
| getRelatedItems(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& purpose) |
| { |
| if (purpose == sw_util::bmcPurpose) |
| { |
| nlohmann::json& relatedItem = asyncResp->res.jsonValue["RelatedItem"]; |
| nlohmann::json::object_t item; |
| item["@odata.id"] = "/redfish/v1/Managers/bmc"; |
| relatedItem.emplace_back(std::move(item)); |
| asyncResp->res.jsonValue["RelatedItem@odata.count"] = |
| relatedItem.size(); |
| } |
| else if (purpose == sw_util::biosPurpose) |
| { |
| nlohmann::json& relatedItem = asyncResp->res.jsonValue["RelatedItem"]; |
| nlohmann::json::object_t item; |
| item["@odata.id"] = "/redfish/v1/Systems/system/Bios"; |
| relatedItem.emplace_back(std::move(item)); |
| asyncResp->res.jsonValue["RelatedItem@odata.count"] = |
| relatedItem.size(); |
| } |
| else |
| { |
| BMCWEB_LOG_DEBUG("Unknown software purpose {}", purpose); |
| } |
| } |
| |
| inline void |
| getSoftwareVersion(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& service, const std::string& path, |
| const std::string& swId) |
| { |
| sdbusplus::asio::getAllProperties( |
| *crow::connections::systemBus, service, path, |
| "xyz.openbmc_project.Software.Version", |
| [asyncResp, |
| swId](const boost::system::error_code& ec, |
| const dbus::utility::DBusPropertiesMap& propertiesList) { |
| if (ec) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| const std::string* swInvPurpose = nullptr; |
| const std::string* version = nullptr; |
| |
| const bool success = sdbusplus::unpackPropertiesNoThrow( |
| dbus_utils::UnpackErrorPrinter(), propertiesList, "Purpose", |
| swInvPurpose, "Version", version); |
| |
| if (!success) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| if (swInvPurpose == nullptr) |
| { |
| BMCWEB_LOG_DEBUG("Can't find property \"Purpose\"!"); |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG("swInvPurpose = {}", *swInvPurpose); |
| |
| if (version == nullptr) |
| { |
| BMCWEB_LOG_DEBUG("Can't find property \"Version\"!"); |
| |
| messages::internalError(asyncResp->res); |
| |
| return; |
| } |
| asyncResp->res.jsonValue["Version"] = *version; |
| asyncResp->res.jsonValue["Id"] = swId; |
| |
| // swInvPurpose is of format: |
| // xyz.openbmc_project.Software.Version.VersionPurpose.ABC |
| // Translate this to "ABC image" |
| size_t endDesc = swInvPurpose->rfind('.'); |
| if (endDesc == std::string::npos) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| endDesc++; |
| if (endDesc >= swInvPurpose->size()) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| std::string formatDesc = swInvPurpose->substr(endDesc); |
| asyncResp->res.jsonValue["Description"] = formatDesc + " image"; |
| getRelatedItems(asyncResp, *swInvPurpose); |
| }); |
| } |
| |
| inline void requestRoutesSoftwareInventory(App& app) |
| { |
| BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/FirmwareInventory/<str>/") |
| .privileges(redfish::privileges::getSoftwareInventory) |
| .methods(boost::beast::http::verb::get)( |
| [&app](const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& param) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| std::shared_ptr<std::string> swId = |
| std::make_shared<std::string>(param); |
| |
| asyncResp->res.jsonValue["@odata.id"] = boost::urls::format( |
| "/redfish/v1/UpdateService/FirmwareInventory/{}", *swId); |
| |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.Software.Version"}; |
| dbus::utility::getSubTree( |
| "/", 0, interfaces, |
| [asyncResp, |
| swId](const boost::system::error_code& ec, |
| const dbus::utility::MapperGetSubTreeResponse& subtree) { |
| BMCWEB_LOG_DEBUG("doGet callback..."); |
| if (ec) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| // Ensure we find our input swId, otherwise return an error |
| bool found = false; |
| for (const std::pair<std::string, |
| std::vector<std::pair< |
| std::string, std::vector<std::string>>>>& |
| obj : subtree) |
| { |
| if (!obj.first.ends_with(*swId)) |
| { |
| continue; |
| } |
| |
| if (obj.second.empty()) |
| { |
| continue; |
| } |
| |
| found = true; |
| sw_util::getSwStatus(asyncResp, swId, obj.second[0].first); |
| getSoftwareVersion(asyncResp, obj.second[0].first, obj.first, |
| *swId); |
| } |
| if (!found) |
| { |
| BMCWEB_LOG_WARNING("Input swID {} not found!", *swId); |
| messages::resourceMissingAtURI( |
| asyncResp->res, |
| boost::urls::format( |
| "/redfish/v1/UpdateService/FirmwareInventory/{}", |
| *swId)); |
| return; |
| } |
| asyncResp->res.jsonValue["@odata.type"] = |
| "#SoftwareInventory.v1_1_0.SoftwareInventory"; |
| asyncResp->res.jsonValue["Name"] = "Software Inventory"; |
| asyncResp->res.jsonValue["Status"]["HealthRollup"] = "OK"; |
| |
| asyncResp->res.jsonValue["Updateable"] = false; |
| sw_util::getSwUpdatableStatus(asyncResp, swId); |
| }); |
| }); |
| } |
| |
| } // namespace redfish |