1 /*
2 // Copyright (c) 2020 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 <sdbusplus/asio/object_server.hpp>
19 #include <sdbusplus/server.hpp>
20 #include <xyz/openbmc_project/BIOSConfig/Manager/server.hpp>
21 
22 #include <filesystem>
23 #include <string>
24 
25 namespace bios_config
26 {
27 
28 static constexpr auto service = "xyz.openbmc_project.BIOSConfigManager";
29 static constexpr auto objectPath = "/xyz/openbmc_project/bios_config/manager";
30 constexpr auto biosPersistFile = "biosData";
31 
32 using Base = sdbusplus::xyz::openbmc_project::BIOSConfig::server::Manager;
33 namespace fs = std::filesystem;
34 
35 /** @class Manager
36  *
37  *  @brief Implements the BIOS Manager
38  */
39 class Manager : public Base
40 {
41   public:
42     using BaseTable = std::map<
43         std::string,
44         std::tuple<
45             AttributeType, bool, std::string, std::string, std::string,
46             std::variant<int64_t, std::string>,
47             std::variant<int64_t, std::string>,
48             std::vector<std::tuple<
49                 BoundType, std::variant<int64_t, std::string>, std::string>>>>;
50 
51     using ResetFlag = std::map<std::string, ResetFlag>;
52 
53     using PendingAttributes =
54         std::map<std::string,
55                  std::tuple<AttributeType, std::variant<int64_t, std::string>>>;
56 
57     using PendingAttribute =
58         std::tuple<AttributeType, std::variant<int64_t, std::string>>;
59 
60     using AttributeName = std::string;
61     using AttributeValue = std::variant<int64_t, std::string>;
62     using CurrentValue = std::variant<int64_t, std::string>;
63     using PendingValue = std::variant<int64_t, std::string>;
64     using AttributeDetails =
65         std::tuple<AttributeType, CurrentValue, PendingValue>;
66 
67     Manager() = delete;
68     ~Manager() = default;
69     Manager(const Manager&) = delete;
70     Manager& operator=(const Manager&) = delete;
71     Manager(Manager&&) = delete;
72     Manager& operator=(Manager&&) = delete;
73 
74     /** @brief Constructs Manager object.
75      *
76      *  @param[in] objectServer  - object server
77      *  @param[in] systemBus - bus connection
78      */
79     Manager(sdbusplus::asio::object_server& objectServer,
80             std::shared_ptr<sdbusplus::asio::connection>& systemBus,
81             std::string persistPath);
82 
83     /** @brief Set the BIOS attribute with a new value, the new value is added
84      *         to the PendingAttribute.
85      *
86      *  @param[in] attribute - attribute name
87      *  @param[in] value - new value for the attribute
88      *
89      *  @return On error, throw exception
90      */
91     void setAttribute(AttributeName attribute, AttributeValue value) override;
92 
93     /** @brief Get the details of the BIOS attribute
94      *
95      *  @param[in] attribute - attribute name
96      *
97      *  @return On success, return the attribute details: attribute type,
98      *          current value, pending value. On error, throw exception
99      */
100     AttributeDetails getAttribute(AttributeName attribute) override;
101 
102     /** @brief Set the BaseBIOSTable property and clears the PendingAttributes
103      *         property
104      *
105      *  @param[in] value - new BaseBIOSTable
106      *
107      *  @return The new BaseBIOSTable that is applied.
108      */
109     BaseTable baseBIOSTable(BaseTable value) override;
110 
111     ResetFlag resetBIOSSettings(ResetFlag value);
112 
113     /** @brief Set the PendingAttributes property, additionally checks if the
114      *         attributes are in the BaseBIOSTable, whether the attributes are
115      *         read only and validate the attribute value based on the
116      *         attribute type. PendingAttributes is cleared if value is empty.
117      *
118      *  @param[in] value - new PendingAttributes to append to the
119      *                     PendingAttributes property
120      *
121      *  @return On success, return the new PendingAttributes property that is
122      *          set.Throw exception if the validation fails.
123      */
124     PendingAttributes pendingAttributes(PendingAttributes value) override;
125 
126   private:
127     /** @enum Index into the fields in the BaseBIOSTable
128      */
129     enum class Index : uint8_t
130     {
131         attributeType = 0,
132         readOnly,
133         displayName,
134         description,
135         menuPath,
136         currentValue,
137         defaultValue,
138         options,
139     };
140 
141     bool validateEnumOption(
142         const std::string& attrValue,
143         const std::vector<std::tuple<
144             BoundType, std::variant<int64_t, std::string>, std::string>>&
145             options);
146 
147     bool validateStringOption(
148         const std::string& attrValue,
149         const std::vector<std::tuple<
150             BoundType, std::variant<int64_t, std::string>, std::string>>&
151             options);
152 
153     bool validateIntegerOption(
154         const int64_t& attrValue,
155         const std::vector<std::tuple<
156             BoundType, std::variant<int64_t, std::string>, std::string>>&
157             options);
158 
159     sdbusplus::asio::object_server& objServer;
160     std::shared_ptr<sdbusplus::asio::connection>& systemBus;
161     std::filesystem::path biosFile;
162 };
163 
164 } // namespace bios_config
165