path: root/redfish-core/include/utils/fw_utils.hpp

#pragma once
#include <async_resp.hpp>

#include <string>
#include <variant>

namespace redfish
{
namespace fw_util
{
/* @brief String that indicates a bios firmware instance */
constexpr const char* biosPurpose =
    "xyz.openbmc_project.Software.Version.VersionPurpose.Host";

/* @brief String that indicates a BMC firmware instance */
constexpr const char* bmcPurpose =
    "xyz.openbmc_project.Software.Version.VersionPurpose.BMC";

/**
 * @brief Put fw version of input type into async response json structure
 *
 * @param[i,o] aResp             Async response object
 * @param[i]   fwVersionPurpose  Indicates what target to look for
 * @param[i]   activeVersionPropName  Index in aResp->res.jsonValue to write
 * the running firmware version to
 * @param[i]   populateLinkToActiveImage  Populate aResp->res "Links"
 * "ActiveSoftwareImage" with a link to the running firmware image
 *
 * @return void
 */
inline void getActiveFwVersion(std::shared_ptr<AsyncResp> aResp,
                               const std::string& fwVersionPurpose,
                               const std::string& activeVersionPropName,
                               const bool populateLinkToActiveImage)
{
    // Get active FW images
    crow::connections::systemBus->async_method_call(
        [aResp, fwVersionPurpose, activeVersionPropName,
         populateLinkToActiveImage](
            const boost::system::error_code ec,
            const std::variant<std::vector<std::string>>& resp) {
            if (ec)
            {
                BMCWEB_LOG_ERROR << "error_code = " << ec;
                BMCWEB_LOG_ERROR << "error msg = " << ec.message();
                messages::internalError(aResp->res);
                return;
            }
            const std::vector<std::string>* functionalFw =
                std::get_if<std::vector<std::string>>(&resp);
            if ((functionalFw == nullptr) || (functionalFw->size() == 0))
            {
                BMCWEB_LOG_ERROR << "Zero functional software in system";
                messages::internalError(aResp->res);
                return;
            }
            // example functionalFw:
            // v as 2 "/xyz/openbmc_project/software/ace821ef"
            //        "/xyz/openbmc_project/software/230fb078"
            for (auto& fw : *functionalFw)
            {
                // if can't parse fw id then return
                std::string::size_type idPos = fw.rfind("/");
                if (idPos == std::string::npos)
                {
                    messages::internalError(aResp->res);
                    BMCWEB_LOG_DEBUG << "Can't parse firmware ID!!";
                    return;
                }
                idPos++;
                if (idPos >= fw.size())
                {
                    messages::internalError(aResp->res);
                    BMCWEB_LOG_DEBUG << "Invalid firmware ID";
                    return;
                }
                std::string swId = fw.substr(idPos);

                // Now find service that hosts it
                crow::connections::systemBus->async_method_call(
                    [aResp, fw, swId, fwVersionPurpose, activeVersionPropName,
                     populateLinkToActiveImage](
                        const boost::system::error_code ec2,
                        const std::vector<std::pair<
                            std::string, std::vector<std::string>>>& objInfo) {
                        if (ec2)
                        {
                            BMCWEB_LOG_DEBUG << "error_code = " << ec2;
                            BMCWEB_LOG_DEBUG << "error msg = " << ec2.message();
                            messages::internalError(aResp->res);
                            return;
                        }
                        // Example objInfo
                        // a{sas} 1 "org.open_power.Software.Host.Updater" 10
                        // "org.freedesktop.DBus.Introspectable"
                        // "org.freedesktop.DBus.Peer"
                        // "org.freedesktop.DBus.Properties"
                        // "org.openbmc.Associations"
                        // "xyz.openbmc_project.Common.FilePath"
                        // "xyz.openbmc_project.Object.Delete"
                        // "xyz.openbmc_project.Software.Activation"
                        // "xyz.openbmc_project.Software.ExtendedVersion"
                        // "xyz.openbmc_project.Software.RedundancyPriority"
                        // "xyz.openbmc_project.Software.Version"

                        // Ensure we only got one service back
                        if (objInfo.size() != 1)
                        {
                            BMCWEB_LOG_ERROR << "Invalid Object Size "
                                             << objInfo.size();
                            messages::internalError(aResp->res);
                            return;
                        }

                        // Now grab its version info
                        crow::connections::systemBus->async_method_call(
                            [aResp, swId, fwVersionPurpose,
                             activeVersionPropName, populateLinkToActiveImage](
                                const boost::system::error_code ec3,
                                const boost::container::flat_map<
                                    std::string,
                                    std::variant<bool, std::string, uint64_t,
                                                 uint32_t>>& propertiesList) {
                                if (ec3)
                                {
                                    BMCWEB_LOG_ERROR << "error_code = " << ec3;
                                    BMCWEB_LOG_ERROR << "error msg = "
                                                     << ec3.message();
                                    messages::internalError(aResp->res);
                                    return;
                                }
                                // example propertiesList
                                // a{sv} 2 "Version" s
                                // "IBM-witherspoon-OP9-v2.0.10-2.22" "Purpose"
                                // s
                                // "xyz.openbmc_project.Software.Version.VersionPurpose.Host"

                                boost::container::flat_map<
                                    std::string,
                                    std::variant<bool, std::string, uint64_t,
                                                 uint32_t>>::const_iterator it =
                                    propertiesList.find("Purpose");
                                if (it == propertiesList.end())
                                {
                                    BMCWEB_LOG_DEBUG
                                        << "Can't find property \"Purpose\"!";
                                    messages::internalError(aResp->res);
                                    return;
                                }
                                const std::string* swInvPurpose =
                                    std::get_if<std::string>(&it->second);
                                if (swInvPurpose == nullptr)
                                {
                                    BMCWEB_LOG_DEBUG << "wrong types for "
                                                        "property \"Purpose\"!";
                                    messages::internalError(aResp->res);
                                    return;
                                }

                                if (*swInvPurpose != fwVersionPurpose)
                                {
                                    // Not purpose we're looking for
                                    return;
                                }
                                if (populateLinkToActiveImage)
                                {
                                    // Firmware images are at
                                    // /redfish/v1/UpdateService/FirmwareInventory/<Id>
                                    // e.g. .../FirmwareInventory/82d3ec86
                                    // Create the link to the running one
                                    aResp->res
                                        .jsonValue["Links"]
                                                  ["ActiveSoftwareImage"] = {
                                        {"@odata.id",
                                         "/redfish/v1/UpdateService/"
                                         "FirmwareInventory/" +
                                             swId}};
                                }
                                if (!activeVersionPropName.empty())
                                {
                                    it = propertiesList.find("Version");
                                    if (it == propertiesList.end())
                                    {
                                        BMCWEB_LOG_DEBUG
                                            << "Can't find property "
                                               "\"Version\"!";
                                        messages::internalError(aResp->res);
                                        return;
                                    }
                                    const std::string* version =
                                        std::get_if<std::string>(&it->second);
                                    if (version == nullptr)
                                    {
                                        BMCWEB_LOG_DEBUG
                                            << "Error getting fw version";
                                        messages::internalError(aResp->res);
                                        return;
                                    }

                                    aResp->res
                                        .jsonValue[activeVersionPropName] =
                                        *version;
                                }
                            },
                            objInfo[0].first, fw,
                            "org.freedesktop.DBus.Properties", "GetAll",
                            "xyz.openbmc_project.Software.Version");
                    },
                    "xyz.openbmc_project.ObjectMapper",
                    "/xyz/openbmc_project/object_mapper",
                    "xyz.openbmc_project.ObjectMapper", "GetObject", fw,
                    std::array<const char*, 1>{
                        "xyz.openbmc_project.Software.Activation"});
            }
        },
        "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/software/functional",
        "org.freedesktop.DBus.Properties", "Get",
        "xyz.openbmc_project.Association", "endpoints");

    return;
}

/**
 * @brief Translate input fwState to Redfish state
 *
 * This function will return the corresponding Redfish state
 *
 * @param[i]   fwState  The OpenBMC firmware state
 *
 * @return The corresponding Redfish state
 */
inline std::string getRedfishFWState(const std::string& fwState)
{
    if (fwState == "xyz.openbmc_project.Software.Activation.Activations.Active")
    {
        return "Enabled";
    }
    else if (fwState == "xyz.openbmc_project.Software.Activation."
                        "Activations.Activating")
    {
        return "Updating";
    }
    else if (fwState == "xyz.openbmc_project.Software.Activation."
                        "Activations.StandbySpare")
    {
        return "StandbySpare";
    }
    else
    {
        BMCWEB_LOG_DEBUG << "Default fw state " << fwState << " to Disabled";
        return "Disabled";
    }
}

/**
 * @brief Translate input fwState to Redfish health state
 *
 * This function will return the corresponding Redfish health state
 *
 * @param[i]   fwState  The OpenBMC firmware state
 *
 * @return The corresponding Redfish health state
 */
inline std::string getRedfishFWHealth(const std::string& fwState)
{
    if ((fwState ==
         "xyz.openbmc_project.Software.Activation.Activations.Active") ||
        (fwState == "xyz.openbmc_project.Software.Activation.Activations."
                    "Activating") ||
        (fwState ==
         "xyz.openbmc_project.Software.Activation.Activations.Ready"))
    {
        return "OK";
    }
    else
    {
        BMCWEB_LOG_DEBUG << "FW state " << fwState << " to Warning";
        return "Warning";
    }
}

/**
 * @brief Put status of input swId into json response
 *
 * This function will put the appropriate Redfish state of the input
 * firmware id to ["Status"]["State"] within the json response
 *
 * @param[i,o] aResp    Async response object
 * @param[i]   swId     The software ID to get status for
 * @param[i]   dbusSvc  The dbus service implementing the software object
 *
 * @return void
 */
inline void getFwStatus(std::shared_ptr<AsyncResp> asyncResp,
                        const std::shared_ptr<std::string> swId,
                        const std::string& dbusSvc)
{
    BMCWEB_LOG_DEBUG << "getFwStatus: swId " << *swId << " svc " << dbusSvc;

    crow::connections::systemBus->async_method_call(
        [asyncResp,
         swId](const boost::system::error_code error_code,
               const boost::container::flat_map<
                   std::string, std::variant<bool, std::string, uint64_t,
                                             uint32_t>>& propertiesList) {
            if (error_code)
            {
                // not all fwtypes are updateable, this is ok
                asyncResp->res.jsonValue["Status"]["State"] = "Enabled";
                return;
            }
            boost::container::flat_map<
                std::string, std::variant<bool, std::string, uint64_t,
                                          uint32_t>>::const_iterator it =
                propertiesList.find("Activation");
            if (it == propertiesList.end())
            {
                BMCWEB_LOG_DEBUG << "Can't find property \"Activation\"!";
                messages::propertyMissing(asyncResp->res, "Activation");
                return;
            }
            const std::string* swInvActivation =
                std::get_if<std::string>(&it->second);
            if (swInvActivation == nullptr)
            {
                BMCWEB_LOG_DEBUG << "wrong types for property\"Activation\"!";
                messages::propertyValueTypeError(asyncResp->res, "",
                                                 "Activation");
                return;
            }
            BMCWEB_LOG_DEBUG << "getFwStatus: Activation " << *swInvActivation;
            asyncResp->res.jsonValue["Status"]["State"] =
                getRedfishFWState(*swInvActivation);
            asyncResp->res.jsonValue["Status"]["Health"] =
                getRedfishFWHealth(*swInvActivation);
        },
        dbusSvc, "/xyz/openbmc_project/software/" + *swId,
        "org.freedesktop.DBus.Properties", "GetAll",
        "xyz.openbmc_project.Software.Activation");
}

/**
 * @brief Updates programmable status of input swId into json response
 *
 * This function checks whether firmware inventory component
 * can be programmable or not and fill's the "Updateable"
 * Property.
 *
 * @param[i,o] asyncResp  Async response object
 * @param[i]   fwId       The firmware ID
 */
inline void getFwUpdateableStatus(std::shared_ptr<AsyncResp> asyncResp,
                                  const std::shared_ptr<std::string> fwId)
{
    crow::connections::systemBus->async_method_call(
        [asyncResp, fwId](const boost::system::error_code ec,
                          const std::variant<std::vector<std::string>>& resp) {
            if (ec)
            {
                BMCWEB_LOG_DEBUG << __FUNCTION__ << " error_code = " << ec
                                 << " error msg =  " << ec.message();
                // System can exist with no updateable firmware,
                // so don't throw error here.
                return;
            }
            const std::vector<std::string>* objPaths =
                std::get_if<std::vector<std::string>>(&resp);
            if (objPaths)
            {
                std::string reqFwObjPath =
                    "/xyz/openbmc_project/software/" + *fwId;

                if (std::find((*objPaths).begin(), (*objPaths).end(),
                              reqFwObjPath) != (*objPaths).end())
                {
                    asyncResp->res.jsonValue["Updateable"] = true;
                    return;
                }
            }
            return;
        },
        "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/software/updateable",
        "org.freedesktop.DBus.Properties", "Get",
        "xyz.openbmc_project.Association", "endpoints");

    return;
}

} // namespace fw_util
} // namespace redfish