1 #include "version.hpp"
2 
3 #include "item_updater.hpp"
4 #include "xyz/openbmc_project/Common/error.hpp"
5 
6 #include <openssl/evp.h>
7 
8 #include <phosphor-logging/elog-errors.hpp>
9 #include <phosphor-logging/log.hpp>
10 
11 #include <fstream>
12 #include <iostream>
13 #include <sstream>
14 #include <stdexcept>
15 #include <string>
16 
17 namespace openpower
18 {
19 namespace software
20 {
21 namespace updater
22 {
23 
24 using namespace sdbusplus::xyz::openbmc_project::Common::Error;
25 using namespace phosphor::logging;
26 using Argument = xyz::openbmc_project::Common::InvalidArgument;
27 
28 using EVP_MD_CTX_Ptr =
29     std::unique_ptr<EVP_MD_CTX, decltype(&::EVP_MD_CTX_free)>;
30 
31 std::string Version::getId(const std::string& version)
32 {
33     if (version.empty())
34     {
35         log<level::ERR>("Error version is empty");
36         return {};
37     }
38 
39     std::array<unsigned char, EVP_MAX_MD_SIZE> digest{};
40     EVP_MD_CTX_Ptr ctx(EVP_MD_CTX_new(), &::EVP_MD_CTX_free);
41 
42     EVP_DigestInit(ctx.get(), EVP_sha512());
43     EVP_DigestUpdate(ctx.get(), version.c_str(), strlen(version.c_str()));
44     EVP_DigestFinal(ctx.get(), digest.data(), nullptr);
45 
46     // We are only using the first 8 characters.
47     char mdString[9];
48     snprintf(mdString, sizeof(mdString), "%02x%02x%02x%02x",
49              (unsigned int)digest[0], (unsigned int)digest[1],
50              (unsigned int)digest[2], (unsigned int)digest[3]);
51 
52     return mdString;
53 }
54 
55 std::map<std::string, std::string>
56     Version::getValue(const std::string& filePath,
57                       std::map<std::string, std::string> keys)
58 {
59     if (filePath.empty())
60     {
61         log<level::ERR>("Error filePath is empty");
62         elog<InvalidArgument>(Argument::ARGUMENT_NAME("FilePath"),
63                               Argument::ARGUMENT_VALUE(filePath.c_str()));
64     }
65 
66     std::ifstream efile;
67     std::string line;
68     efile.exceptions(std::ifstream::failbit | std::ifstream::badbit |
69                      std::ifstream::eofbit);
70 
71     try
72     {
73         efile.open(filePath);
74         while (getline(efile, line))
75         {
76             for (auto& key : keys)
77             {
78                 auto value = key.first + "=";
79                 auto keySize = value.length();
80                 if (line.compare(0, keySize, value) == 0)
81                 {
82                     key.second = line.substr(keySize);
83                     break;
84                 }
85             }
86         }
87         efile.close();
88     }
89     catch (const std::exception& e)
90     {
91         if (!efile.eof())
92         {
93             log<level::ERR>("Error in reading file");
94         }
95         efile.close();
96     }
97 
98     return keys;
99 }
100 
101 std::pair<std::string, std::string>
102     Version::getVersions(const std::string& versionPart)
103 {
104     // versionPart contains strings like below:
105     // open-power-romulus-v2.2-rc1-48-g268344f-dirty
106     //     buildroot-2018.11.1-7-g5d7cc8c
107     //     skiboot-v6.2
108     std::istringstream iss(versionPart);
109     std::string line;
110     std::string version;
111     std::stringstream ss;
112     std::string extendedVersion;
113 
114     if (!std::getline(iss, line))
115     {
116         log<level::ERR>("Unable to read from version",
117                         entry("VERSION=%s", versionPart.c_str()));
118         return {};
119     }
120     version = line;
121 
122     while (std::getline(iss, line))
123     {
124         // Each line starts with a tab, let's trim it
125         line.erase(line.begin(),
126                    std::find_if(line.begin(), line.end(),
127                                 [](int c) { return !std::isspace(c); }));
128         ss << line << ',';
129     }
130     extendedVersion = ss.str();
131 
132     // Erase the last ',', if there is one
133     if (!extendedVersion.empty())
134     {
135         extendedVersion.pop_back();
136     }
137     return {version, extendedVersion};
138 }
139 
140 void Delete::delete_()
141 {
142     if (parent.eraseCallback)
143     {
144         parent.eraseCallback(parent.getId(parent.version()));
145     }
146 }
147 
148 void Version::updateDeleteInterface(sdbusplus::message_t& msg)
149 {
150     std::string interface, chassisState;
151     std::map<std::string, std::variant<std::string>> properties;
152 
153     msg.read(interface, properties);
154 
155     for (const auto& p : properties)
156     {
157         if (p.first == "CurrentPowerState")
158         {
159             chassisState = std::get<std::string>(p.second);
160         }
161     }
162     if (chassisState.empty())
163     {
164         // The chassis power state property did not change, return.
165         return;
166     }
167 
168     if ((parent.isVersionFunctional(this->versionId)) &&
169         (chassisState != CHASSIS_STATE_OFF))
170     {
171         if (deleteObject)
172         {
173             deleteObject.reset(nullptr);
174         }
175     }
176     else
177     {
178         if (!deleteObject)
179         {
180             deleteObject = std::make_unique<Delete>(bus, objPath, *this);
181         }
182     }
183 }
184 
185 } // namespace updater
186 } // namespace software
187 } // namespace openpower
188