1 #pragma once
2 
3 #include "bios_table.h"
4 
5 #include "bios_attribute.hpp"
6 #include "bios_table.hpp"
7 
8 #include <nlohmann/json.hpp>
9 
10 #include <functional>
11 #include <iostream>
12 #include <memory>
13 #include <optional>
14 #include <set>
15 #include <string>
16 #include <vector>
17 
18 namespace pldm
19 {
20 namespace responder
21 {
22 namespace bios
23 {
24 
25 /** @class BIOSConfig
26  *  @brief Manager BIOS Attributes
27  */
28 class BIOSConfig
29 {
30   public:
31     BIOSConfig() = delete;
32     BIOSConfig(const BIOSConfig&) = delete;
33     BIOSConfig(BIOSConfig&&) = delete;
34     BIOSConfig& operator=(const BIOSConfig&) = delete;
35     BIOSConfig& operator=(BIOSConfig&&) = delete;
36     ~BIOSConfig() = default;
37 
38     /** @brief Construct BIOSConfig
39      *  @param[in] jsonDir - The directory where json file exists
40      *  @param[in] tableDir - The directory where the persistent table is placed
41      *  @param[in] dbusHandler - Dbus Handler
42      */
43     explicit BIOSConfig(const char* jsonDir, const char* tableDir,
44                         DBusHandler* const dbusHandler);
45 
46     /** @brief Set attribute value on dbus and attribute value table
47      *  @param[in] entry - attribute value entry
48      *  @param[in] size - size of the attribute value entry
49      *  @return pldm_completion_codes
50      */
51     int setAttrValue(const void* entry, size_t size);
52 
53     /** @brief Remove the persistent tables */
54     void removeTables();
55 
56     /** @brief Build bios tables(string,attribute,attribute value table)*/
57     void buildTables();
58 
59     /** @brief Get BIOS table of specified type
60      *  @param[in] tableType - The table type
61      *  @return The bios table, std::nullopt if the table is unaviliable
62      */
63     std::optional<Table> getBIOSTable(pldm_bios_table_types tableType);
64 
65   private:
66     const fs::path jsonDir;
67     const fs::path tableDir;
68     DBusHandler* const dbusHandler;
69 
70     // vector persists all attributes
71     using BIOSAttributes = std::vector<std::unique_ptr<BIOSAttribute>>;
72     BIOSAttributes biosAttributes;
73 
74     using propName = std::string;
75     using DbusChObjProperties = std::map<propName, PropertyValue>;
76 
77     // vector to catch the D-Bus property change signals for BIOS attributes
78     std::vector<std::unique_ptr<sdbusplus::bus::match::match>> biosAttrMatch;
79 
80     /** @brief Method to update a BIOS attribute when the corresponding Dbus
81      *  property is changed
82      *  @param[in] chProperties - list of properties which have changed
83      *  @param[in] biosAttrIndex - Index of BIOSAttribute pointer in
84      * biosAttributes
85      *  @return - none
86      */
87     void processBiosAttrChangeNotification(
88         const DbusChObjProperties& chProperties, uint32_t biosAttrIndex);
89 
90     /** @brief Construct an attribute and persist it
91      *  @tparam T - attribute type
92      *  @param[in] entry - json entry
93      */
94     template <typename T>
95     void constructAttribute(const Json& entry)
96     {
97         try
98         {
99             biosAttributes.push_back(std::make_unique<T>(entry, dbusHandler));
100             auto biosAttrIndex = biosAttributes.size() - 1;
101             auto dBusMap = biosAttributes[biosAttrIndex]->getDBusMap();
102 
103             if (dBusMap.has_value())
104             {
105                 using namespace sdbusplus::bus::match::rules;
106                 biosAttrMatch.push_back(
107                     std::make_unique<sdbusplus::bus::match::match>(
108                         pldm::utils::DBusHandler::getBus(),
109                         propertiesChanged(dBusMap->objectPath,
110                                           dBusMap->interface),
111                         [this,
112                          biosAttrIndex](sdbusplus::message::message& msg) {
113                             DbusChObjProperties props;
114                             std::string iface;
115                             msg.read(iface, props);
116                             processBiosAttrChangeNotification(props,
117                                                               biosAttrIndex);
118                         }));
119             }
120         }
121         catch (const std::exception& e)
122         {
123             std::cerr << "Constructs Attribute Error, " << e.what()
124                       << std::endl;
125         }
126     }
127 
128     /** Construct attributes and persist them */
129     void constructAttributes();
130 
131     using ParseHandler = std::function<void(const Json& entry)>;
132 
133     /** @brief Helper function to parse json
134      *  @param[in] filePath - Path of json file
135      *  @param[in] handler - Handler to process each entry in the json
136      */
137     void load(const fs::path& filePath, ParseHandler handler);
138 
139     /** @brief Build String Table and persist it
140      *  @return The built string table, std::nullopt if it fails.
141      */
142     std::optional<Table> buildAndStoreStringTable();
143 
144     /** @brief Build attr table and attr value table and persist them
145      *  @param[in] stringTable - The string Table
146      */
147     void buildAndStoreAttrTables(const Table& stringTable);
148 
149     /** @brief Persist the table
150      *  @param[in] path - Path to persist the table
151      *  @param[in] table - The table
152      */
153     void storeTable(const fs::path& path, const Table& table);
154 
155     /** @brief Load bios table to ram
156      *  @param[in] path - Path of the table
157      *  @return The table, std::nullopt if loading fails
158      */
159     std::optional<Table> loadTable(const fs::path& path);
160 
161     /** @brief Check the attribute value to update
162      *  @param[in] attrValueEntry - The attribute value entry to update
163      *  @param[in] attrEntry - The attribute table entry
164      *  @param[in] stringTable - The string  table
165      *  @return pldm_completion_codes
166      */
167     int checkAttrValueToUpdate(
168         const pldm_bios_attr_val_table_entry* attrValueEntry,
169         const pldm_bios_attr_table_entry* attrEntry, Table& stringTable);
170 };
171 
172 } // namespace bios
173 } // namespace responder
174 } // namespace pldm
175