1 #pragma once
2 
3 #include "libpldm/bios_table.h"
4 
5 #include "bios_attribute.hpp"
6 #include "bios_table.hpp"
7 #include "pldmd/dbus_impl_requester.hpp"
8 #include "requester/handler.hpp"
9 
10 #include <nlohmann/json.hpp>
11 
12 #include <functional>
13 #include <iostream>
14 #include <memory>
15 #include <optional>
16 #include <set>
17 #include <string>
18 #include <vector>
19 
20 namespace pldm
21 {
22 namespace responder
23 {
24 namespace bios
25 {
26 enum class BoundType
27 {
28     LowerBound,
29     UpperBound,
30     ScalarIncrement,
31     MinStringLength,
32     MaxStringLength,
33     OneOf
34 };
35 
36 using AttributeName = std::string;
37 using AttributeType = std::string;
38 using ReadonlyStatus = bool;
39 using DisplayName = std::string;
40 using Description = std::string;
41 using MenuPath = std::string;
42 using CurrentValue = std::variant<int64_t, std::string>;
43 using DefaultValue = std::variant<int64_t, std::string>;
44 using OptionString = std::string;
45 using OptionValue = std::variant<int64_t, std::string>;
46 using Option = std::vector<std::tuple<OptionString, OptionValue>>;
47 using BIOSTableObj =
48     std::tuple<AttributeType, ReadonlyStatus, DisplayName, Description,
49                MenuPath, CurrentValue, DefaultValue, Option>;
50 using BaseBIOSTable = std::map<AttributeName, BIOSTableObj>;
51 
52 using PendingObj = std::tuple<AttributeType, CurrentValue>;
53 using PendingAttributes = std::map<AttributeName, PendingObj>;
54 
55 /** @class BIOSConfig
56  *  @brief Manager BIOS Attributes
57  */
58 class BIOSConfig
59 {
60   public:
61     BIOSConfig() = delete;
62     BIOSConfig(const BIOSConfig&) = delete;
63     BIOSConfig(BIOSConfig&&) = delete;
64     BIOSConfig& operator=(const BIOSConfig&) = delete;
65     BIOSConfig& operator=(BIOSConfig&&) = delete;
66     ~BIOSConfig() = default;
67 
68     /** @brief Construct BIOSConfig
69      *  @param[in] jsonDir - The directory where json file exists
70      *  @param[in] tableDir - The directory where the persistent table is placed
71      *  @param[in] dbusHandler - Dbus Handler
72      *  @param[in] fd - socket descriptor to communicate to host
73      *  @param[in] eid - MCTP EID of host firmware
74      *  @param[in] requester - pointer to Requester object
75      *  @param[in] handler - PLDM request handler
76      */
77     explicit BIOSConfig(
78         const char* jsonDir, const char* tableDir,
79         pldm::utils::DBusHandler* const dbusHandler, int fd, uint8_t eid,
80         dbus_api::Requester* requester,
81         pldm::requester::Handler<pldm::requester::Request>* handler);
82 
83     /** @brief Set attribute value on dbus and attribute value table
84      *  @param[in] entry - attribute value entry
85      *  @param[in] size - size of the attribute value entry
86      *  @param[in] isBMC - indicates if the attribute is set by BMC
87      *  @param[in] updateDBus          - update Attr value D-Bus property
88      *                                   if this is set to true
89      *  @param[in] updateBaseBIOSTable - update BaseBIOSTable D-Bus property
90      *                                   if this is set to true
91      *  @return pldm_completion_codes
92      */
93     int setAttrValue(const void* entry, size_t size, bool isBMC,
94                      bool updateDBus = true, bool updateBaseBIOSTable = true);
95 
96     /** @brief Remove the persistent tables */
97     void removeTables();
98 
99     /** @brief Build bios tables(string,attribute,attribute value table)*/
100     void buildTables();
101 
102     /** @brief Get BIOS table of specified type
103      *  @param[in] tableType - The table type
104      *  @return The bios table, std::nullopt if the table is unaviliable
105      */
106     std::optional<Table> getBIOSTable(pldm_bios_table_types tableType);
107 
108     /** @brief set BIOS table
109      *  @param[in] tableType - Indicates what table is being transferred
110      *             {BIOSStringTable=0x0, BIOSAttributeTable=0x1,
111      *              BIOSAttributeValueTable=0x2}
112      *  @param[in] table - table data
113      *  @param[in] updateBaseBIOSTable - update BaseBIOSTable D-Bus property
114      *                                   if this is set to true
115      *  @return pldm_completion_codes
116      */
117     int setBIOSTable(uint8_t tableType, const Table& table,
118                      bool updateBaseBIOSTable = true);
119 
120   private:
121     /** @enum Index into the fields in the BaseBIOSTable
122      */
123     enum class Index : uint8_t
124     {
125         attributeType = 0,
126         readOnly,
127         displayName,
128         description,
129         menuPath,
130         currentValue,
131         defaultValue,
132         options,
133     };
134 
135     const fs::path jsonDir;
136     const fs::path tableDir;
137     pldm::utils::DBusHandler* const dbusHandler;
138     BaseBIOSTable baseBIOSTableMaps;
139 
140     /** @brief socket descriptor to communicate to host */
141     int fd;
142 
143     /** @brief MCTP EID of host firmware */
144     uint8_t eid;
145 
146     /** @brief pointer to Requester object, primarily used to access API to
147      *  obtain PLDM instance id.
148      */
149     dbus_api::Requester* requester;
150 
151     /** @brief PLDM request handler */
152     pldm::requester::Handler<pldm::requester::Request>* handler;
153 
154     // vector persists all attributes
155     using BIOSAttributes = std::vector<std::unique_ptr<BIOSAttribute>>;
156     BIOSAttributes biosAttributes;
157 
158     using propName = std::string;
159     using DbusChObjProperties = std::map<propName, pldm::utils::PropertyValue>;
160 
161     // vector to catch the D-Bus property change signals for BIOS attributes
162     std::vector<std::unique_ptr<sdbusplus::bus::match_t>> biosAttrMatch;
163 
164     /** @brief Method to update a BIOS attribute when the corresponding Dbus
165      *  property is changed
166      *  @param[in] chProperties - list of properties which have changed
167      *  @param[in] biosAttrIndex - Index of BIOSAttribute pointer in
168      * biosAttributes
169      *  @return - none
170      */
171     void processBiosAttrChangeNotification(
172         const DbusChObjProperties& chProperties, uint32_t biosAttrIndex);
173 
174     /** @brief Construct an attribute and persist it
175      *  @tparam T - attribute type
176      *  @param[in] entry - json entry
177      */
178     template <typename T>
179     void constructAttribute(const Json& entry)
180     {
181         try
182         {
183             biosAttributes.push_back(std::make_unique<T>(entry, dbusHandler));
184             auto biosAttrIndex = biosAttributes.size() - 1;
185             auto dBusMap = biosAttributes[biosAttrIndex]->getDBusMap();
186 
187             if (dBusMap.has_value())
188             {
189                 using namespace sdbusplus::bus::match::rules;
190                 biosAttrMatch.push_back(
191                     std::make_unique<sdbusplus::bus::match_t>(
192                         pldm::utils::DBusHandler::getBus(),
193                         propertiesChanged(dBusMap->objectPath,
194                                           dBusMap->interface),
195                         [this, biosAttrIndex](sdbusplus::message_t& msg) {
196                             DbusChObjProperties props;
197                             std::string iface;
198                             msg.read(iface, props);
199                             processBiosAttrChangeNotification(props,
200                                                               biosAttrIndex);
201                         }));
202             }
203         }
204         catch (const std::exception& e)
205         {
206             std::cerr << "Constructs Attribute Error, " << e.what()
207                       << std::endl;
208         }
209     }
210 
211     /** Construct attributes and persist them */
212     void constructAttributes();
213 
214     using ParseHandler = std::function<void(const Json& entry)>;
215 
216     /** @brief Helper function to parse json
217      *  @param[in] filePath - Path of json file
218      *  @param[in] handler - Handler to process each entry in the json
219      */
220     void load(const fs::path& filePath, ParseHandler handler);
221 
222     /** @brief Build String Table and persist it
223      *  @return The built string table, std::nullopt if it fails.
224      */
225     std::optional<Table> buildAndStoreStringTable();
226 
227     /** @brief Build attribute table and attribute value table and persist them
228      *         Read the BaseBIOSTable from the bios-settings-manager and update
229      *         attribute table and attribute value table.
230      *
231      *  @param[in] stringTable - The string Table
232      */
233     void buildAndStoreAttrTables(const Table& stringTable);
234 
235     /** @brief Persist the table
236      *  @param[in] path - Path to persist the table
237      *  @param[in] table - The table
238      */
239     void storeTable(const fs::path& path, const Table& table);
240 
241     /** @brief Load bios table to ram
242      *  @param[in] path - Path of the table
243      *  @return The table, std::nullopt if loading fails
244      */
245     std::optional<Table> loadTable(const fs::path& path);
246 
247     /** @brief Method to decode the attribute name from the string handle
248      *
249      *  @param[in] stringEntry - string entry from string table
250      *  @return the decoded string
251      */
252     std::string decodeStringFromStringEntry(
253         const pldm_bios_string_table_entry* stringEntry);
254 
255     /** @brief Method to print the string Handle by passing the attribute Handle
256      *         of the bios attribute that got updated
257      *
258      *  @param[in] handle - the Attribute handle of the bios attribute
259      *  @param[in] index - index to the possible value handles
260      *  @param[in] attrTable - the attribute table
261      *  @param[in] stringTable - the string table
262      *  @return string handle from the string table and decoded string to the
263      * name handle
264      */
265     std::string displayStringHandle(uint16_t handle, uint8_t index,
266                                     const std::optional<Table>& attrTable,
267                                     const std::optional<Table>& stringTable);
268 
269     /** @brief Method to trace the bios attribute which got changed
270      *
271      *  @param[in] attrValueEntry - The attribute value entry to update
272      *  @param[in] attrEntry - The attribute table entry
273      *  @param[in] isBMC - indicates if the attribute is set by BMC
274      */
275     void traceBIOSUpdate(const pldm_bios_attr_val_table_entry* attrValueEntry,
276                          const pldm_bios_attr_table_entry* attrEntry,
277                          bool isBMC);
278 
279     /** @brief Check the attribute value to update
280      *  @param[in] attrValueEntry - The attribute value entry to update
281      *  @param[in] attrEntry - The attribute table entry
282      *  @param[in] stringTable - The string  table
283      *  @return pldm_completion_codes
284      */
285     int checkAttrValueToUpdate(
286         const pldm_bios_attr_val_table_entry* attrValueEntry,
287         const pldm_bios_attr_table_entry* attrEntry, Table& stringTable);
288 
289     /** @brief Check the attribute table
290      *  @param[in] table - The table
291      *  @return pldm_completion_codes
292      */
293     int checkAttributeTable(const Table& table);
294 
295     /** @brief Check the attribute value table
296      *  @param[in] table - The table
297      *  @return pldm_completion_codes
298      */
299     int checkAttributeValueTable(const Table& table);
300 
301     /** @brief Update the BaseBIOSTable property of the D-Bus interface
302      */
303     void updateBaseBIOSTableProperty();
304 
305     /** @brief Listen the PendingAttributes property of the D-Bus interface and
306      *         update BaseBIOSTable
307      */
308     void listenPendingAttributes();
309 
310     /** @brief Find attribute handle from bios attribute table
311      *  @param[in] attrName - attribute name
312      *  @return attribute handle
313      */
314     uint16_t findAttrHandle(const std::string& attrName);
315 
316     /** @brief Listen the PendingAttributes property of the D-Bus interface
317      * and update BaseBIOSTable
318      *  @param[in] msg - Data associated with subscribed signal
319      */
320     void constructPendingAttribute(const PendingAttributes& pendingAttributes);
321 };
322 
323 } // namespace bios
324 } // namespace responder
325 } // namespace pldm
326