blob: d480c430efcf5d404586506392f34629bdc9a590 [file] [log] [blame]
#include "version.hpp"
#include "item_updater.hpp"
#include "xyz/openbmc_project/Common/error.hpp"
#include <openssl/evp.h>
#include <phosphor-logging/elog-errors.hpp>
#include <phosphor-logging/log.hpp>
#include <fstream>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
namespace openpower
{
namespace software
{
namespace updater
{
using namespace sdbusplus::xyz::openbmc_project::Common::Error;
using namespace phosphor::logging;
using Argument = xyz::openbmc_project::Common::InvalidArgument;
using EVP_MD_CTX_Ptr =
std::unique_ptr<EVP_MD_CTX, decltype(&::EVP_MD_CTX_free)>;
std::string Version::getId(const std::string& version)
{
if (version.empty())
{
log<level::ERR>("Error version is empty");
return {};
}
std::array<unsigned char, EVP_MAX_MD_SIZE> digest{};
EVP_MD_CTX_Ptr ctx(EVP_MD_CTX_new(), &::EVP_MD_CTX_free);
EVP_DigestInit(ctx.get(), EVP_sha512());
EVP_DigestUpdate(ctx.get(), version.c_str(), strlen(version.c_str()));
EVP_DigestFinal(ctx.get(), digest.data(), nullptr);
// We are only using the first 8 characters.
char mdString[9];
snprintf(mdString, sizeof(mdString), "%02x%02x%02x%02x",
(unsigned int)digest[0], (unsigned int)digest[1],
(unsigned int)digest[2], (unsigned int)digest[3]);
return mdString;
}
std::map<std::string, std::string>
Version::getValue(const std::string& filePath,
std::map<std::string, std::string> keys)
{
if (filePath.empty())
{
log<level::ERR>("Error filePath is empty");
elog<InvalidArgument>(Argument::ARGUMENT_NAME("FilePath"),
Argument::ARGUMENT_VALUE(filePath.c_str()));
}
std::ifstream efile;
std::string line;
efile.exceptions(std::ifstream::failbit | std::ifstream::badbit |
std::ifstream::eofbit);
try
{
efile.open(filePath);
while (getline(efile, line))
{
for (auto& key : keys)
{
auto value = key.first + "=";
auto keySize = value.length();
if (line.compare(0, keySize, value) == 0)
{
key.second = line.substr(keySize);
break;
}
}
}
efile.close();
}
catch (const std::exception& e)
{
if (!efile.eof())
{
log<level::ERR>("Error in reading file");
}
efile.close();
}
return keys;
}
std::pair<std::string, std::string>
Version::getVersions(const std::string& versionPart)
{
// versionPart contains strings like below:
// open-power-romulus-v2.2-rc1-48-g268344f-dirty
// buildroot-2018.11.1-7-g5d7cc8c
// skiboot-v6.2
std::istringstream iss(versionPart);
std::string line;
std::string version;
std::stringstream ss;
std::string extendedVersion;
if (!std::getline(iss, line))
{
log<level::ERR>("Unable to read from version",
entry("VERSION=%s", versionPart.c_str()));
return {};
}
version = line;
while (std::getline(iss, line))
{
// Each line starts with a tab, let's trim it
line.erase(line.begin(),
std::find_if(line.begin(), line.end(),
[](int c) { return !std::isspace(c); }));
ss << line << ',';
}
extendedVersion = ss.str();
// Erase the last ',', if there is one
if (!extendedVersion.empty())
{
extendedVersion.pop_back();
}
return {version, extendedVersion};
}
void Delete::delete_()
{
if (parent.eraseCallback)
{
parent.eraseCallback(parent.getId(parent.version()));
}
}
void Version::updateDeleteInterface(sdbusplus::message::message& msg)
{
std::string interface, chassisState;
std::map<std::string, std::variant<std::string>> properties;
msg.read(interface, properties);
for (const auto& p : properties)
{
if (p.first == "CurrentPowerState")
{
chassisState = std::get<std::string>(p.second);
}
}
if (chassisState.empty())
{
// The chassis power state property did not change, return.
return;
}
if ((parent.isVersionFunctional(this->versionId)) &&
(chassisState != CHASSIS_STATE_OFF))
{
if (deleteObject)
{
deleteObject.reset(nullptr);
}
}
else
{
if (!deleteObject)
{
deleteObject = std::make_unique<Delete>(bus, objPath, *this);
}
}
}
} // namespace updater
} // namespace software
} // namespace openpower