blob: 464816ac0d97799774f746463e31d736b29f2102 [file] [log] [blame]
Sampa Misra032bd502019-03-06 05:03:22 -06001#pragma once
2
George Liu6492f522020-06-16 10:34:05 +08003#include "libpldm/base.h"
4#include "libpldm/bios.h"
5#include "libpldm/platform.h"
Tom Joseph54922072021-06-19 02:45:46 -07006#include "libpldm/utils.h"
George Liu6492f522020-06-16 10:34:05 +08007
Sampa Misraaea5dde2020-08-31 08:33:47 -05008#include "types.hpp"
9
Sampa Misra032bd502019-03-06 05:03:22 -060010#include <stdint.h>
11#include <systemd/sd-bus.h>
Jinu Joy Thomasf666db12019-05-29 05:22:31 -050012#include <unistd.h>
Sampa Misra032bd502019-03-06 05:03:22 -060013
George Liu6492f522020-06-16 10:34:05 +080014#include <nlohmann/json.hpp>
15#include <sdbusplus/server.hpp>
16#include <xyz/openbmc_project/Logging/Entry/server.hpp>
17
Sampa Misraa2fa0702019-05-31 01:28:55 -050018#include <exception>
Deepak Kodihalli3cd61812020-03-10 06:38:45 -050019#include <filesystem>
Sampa Misraaa8ae722019-12-12 03:20:40 -060020#include <iostream>
Sampa Misra032bd502019-03-06 05:03:22 -060021#include <string>
Sampa Misraa2fa0702019-05-31 01:28:55 -050022#include <variant>
23#include <vector>
Sampa Misra032bd502019-03-06 05:03:22 -060024
25namespace pldm
26{
Jinu Joy Thomasf666db12019-05-29 05:22:31 -050027namespace utils
28{
29
Deepak Kodihalli3cd61812020-03-10 06:38:45 -050030namespace fs = std::filesystem;
Tom Joseph250c4752020-04-15 10:32:45 +053031using Json = nlohmann::json;
Tom Josephe5268cd2021-09-07 13:04:03 +053032constexpr bool Tx = true;
33constexpr bool Rx = false;
Deepak Kodihalli3cd61812020-03-10 06:38:45 -050034
Jinu Joy Thomasf666db12019-05-29 05:22:31 -050035/** @struct CustomFD
36 *
37 * RAII wrapper for file descriptor.
38 */
39struct CustomFD
40{
41 CustomFD(const CustomFD&) = delete;
42 CustomFD& operator=(const CustomFD&) = delete;
43 CustomFD(CustomFD&&) = delete;
44 CustomFD& operator=(CustomFD&&) = delete;
45
46 CustomFD(int fd) : fd(fd)
George Liu6492f522020-06-16 10:34:05 +080047 {}
Jinu Joy Thomasf666db12019-05-29 05:22:31 -050048
49 ~CustomFD()
50 {
51 if (fd >= 0)
52 {
53 close(fd);
54 }
55 }
56
57 int operator()() const
58 {
59 return fd;
60 }
61
62 private:
63 int fd = -1;
64};
65
Sampa Misrab37be312019-07-03 02:26:41 -050066/** @brief Calculate the pad for PLDM data
67 *
68 * @param[in] data - Length of the data
69 * @return - uint8_t - number of pad bytes
70 */
71uint8_t getNumPadBytes(uint32_t data);
72
George Liu83409572019-12-24 18:42:54 +080073/** @brief Convert uint64 to date
74 *
75 * @param[in] data - time date of uint64
76 * @param[out] year - year number in dec
77 * @param[out] month - month number in dec
78 * @param[out] day - day of the month in dec
79 * @param[out] hour - number of hours in dec
80 * @param[out] min - number of minutes in dec
81 * @param[out] sec - number of seconds in dec
82 * @return true if decode success, false if decode faild
83 */
84bool uintToDate(uint64_t data, uint16_t* year, uint8_t* month, uint8_t* day,
85 uint8_t* hour, uint8_t* min, uint8_t* sec);
86
87/** @brief Convert effecter data to structure of set_effecter_state_field
88 *
89 * @param[in] effecterData - the date of effecter
George Liuba4c1fb2020-02-05 14:13:30 +080090 * @param[in] effecterCount - the number of individual sets of effecter
91 * information
92 * @return[out] parse success and get a valid set_effecter_state_field
93 * structure, return nullopt means parse failed
George Liu83409572019-12-24 18:42:54 +080094 */
George Liuba4c1fb2020-02-05 14:13:30 +080095std::optional<std::vector<set_effecter_state_field>>
96 parseEffecterData(const std::vector<uint8_t>& effecterData,
97 uint8_t effecterCount);
Sampa Misra032bd502019-03-06 05:03:22 -060098
99/**
Sampa Misraaa8ae722019-12-12 03:20:40 -0600100 * @brief creates an error log
101 * @param[in] errorMsg - the error message
102 */
103void reportError(const char* errorMsg);
104
Sampa Misra032bd502019-03-06 05:03:22 -0600105/** @brief Convert any Decimal number to BCD
106 *
107 * @tparam[in] decimal - Decimal number
108 * @return Corresponding BCD number
109 */
110template <typename T>
111T decimalToBcd(T decimal)
112{
113 T bcd = 0;
114 T rem = 0;
115 auto cnt = 0;
116
117 while (decimal)
118 {
119 rem = decimal % 10;
120 bcd = bcd + (rem << cnt);
121 decimal = decimal / 10;
122 cnt += 4;
123 }
124
125 return bcd;
126}
127
Sampa Misraa2fa0702019-05-31 01:28:55 -0500128constexpr auto dbusProperties = "org.freedesktop.DBus.Properties";
Pavithra Barithaya47180ac2020-10-28 02:12:05 -0500129constexpr auto mapperService = "xyz.openbmc_project.ObjectMapper";
Sampa Misraa2fa0702019-05-31 01:28:55 -0500130
George Liu1e44c732020-02-28 20:20:06 +0800131struct DBusMapping
132{
133 std::string objectPath; //!< D-Bus object path
134 std::string interface; //!< D-Bus interface
135 std::string propertyName; //!< D-Bus property name
136 std::string propertyType; //!< D-Bus property type
137};
138
139using PropertyValue =
140 std::variant<bool, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t,
141 uint64_t, double, std::string>;
Deepak Kodihalli6b1d1ca2020-04-27 07:24:51 -0500142using DbusProp = std::string;
143using DbusChangedProps = std::map<DbusProp, PropertyValue>;
Sampa Misraaea5dde2020-08-31 08:33:47 -0500144using DBusInterfaceAdded = std::vector<
145 std::pair<pldm::dbus::Interface,
146 std::vector<std::pair<pldm::dbus::Property,
147 std::variant<pldm::dbus::Property>>>>>;
Manojkiran Eda1ef62c32021-04-24 07:23:18 +0530148using ObjectPath = std::string;
149using ServiceName = std::string;
150using Interfaces = std::vector<std::string>;
151using MapperServiceMap = std::vector<std::pair<ServiceName, Interfaces>>;
152using GetSubTreeResponse = std::vector<std::pair<ObjectPath, MapperServiceMap>>;
George Liu1e44c732020-02-28 20:20:06 +0800153
154/**
155 * @brief The interface for DBusHandler
156 */
157class DBusHandlerInterface
158{
159 public:
160 virtual ~DBusHandlerInterface() = default;
161
George Liu36e81352020-07-01 14:40:30 +0800162 virtual std::string getService(const char* path,
163 const char* interface) const = 0;
Manojkiran Eda1ef62c32021-04-24 07:23:18 +0530164 virtual GetSubTreeResponse
165 getSubtree(const std::string& path, int depth,
166 const std::vector<std::string>& ifaceList) const = 0;
George Liu36e81352020-07-01 14:40:30 +0800167
George Liu1e44c732020-02-28 20:20:06 +0800168 virtual void setDbusProperty(const DBusMapping& dBusMap,
169 const PropertyValue& value) const = 0;
John Wang9e242422020-03-05 08:37:50 +0800170
171 virtual PropertyValue
172 getDbusPropertyVariant(const char* objPath, const char* dbusProp,
173 const char* dbusInterface) const = 0;
George Liu1e44c732020-02-28 20:20:06 +0800174};
175
Sampa Misraa2fa0702019-05-31 01:28:55 -0500176/**
177 * @class DBusHandler
178 *
179 * Wrapper class to handle the D-Bus calls
180 *
181 * This class contains the APIs to handle the D-Bus calls
182 * to cater the request from pldm requester.
183 * A class is created to mock the apis in the test cases
184 */
George Liu1e44c732020-02-28 20:20:06 +0800185class DBusHandler : public DBusHandlerInterface
Sampa Misraa2fa0702019-05-31 01:28:55 -0500186{
187 public:
George Liu0e02c322020-01-01 09:41:51 +0800188 /** @brief Get the bus connection. */
189 static auto& getBus()
190 {
191 static auto bus = sdbusplus::bus::new_default();
192 return bus;
193 }
194
195 /**
196 * @brief Get the DBUS Service name for the input dbus path
John Wang9e242422020-03-05 08:37:50 +0800197 *
George Liu0e02c322020-01-01 09:41:51 +0800198 * @param[in] path - DBUS object path
199 * @param[in] interface - DBUS Interface
John Wang9e242422020-03-05 08:37:50 +0800200 *
George Liu0e02c322020-01-01 09:41:51 +0800201 * @return std::string - the dbus service name
John Wang9e242422020-03-05 08:37:50 +0800202 *
Patrick Williams4fea7a22021-09-02 09:54:12 -0500203 * @throw sdbusplus::exception::exception when it fails
George Liu0e02c322020-01-01 09:41:51 +0800204 */
George Liu36e81352020-07-01 14:40:30 +0800205 std::string getService(const char* path,
206 const char* interface) const override;
George Liu0e02c322020-01-01 09:41:51 +0800207
Manojkiran Eda1ef62c32021-04-24 07:23:18 +0530208 /**
209 * @brief Get the Subtree response from the mapper
210 *
211 * @param[in] path - DBUS object path
212 * @param[in] depth - Search depth
213 * @param[in] ifaceList - list of the interface that are being
214 * queried from the mapper
215 *
216 * @return GetSubTreeResponse - the mapper subtree response
217 *
218 * @throw sdbusplus::exception::exception when it fails
219 */
220 GetSubTreeResponse
221 getSubtree(const std::string& path, int depth,
222 const std::vector<std::string>& ifaceList) const override;
223
John Wang9e242422020-03-05 08:37:50 +0800224 /** @brief Get property(type: variant) from the requested dbus
225 *
226 * @param[in] objPath - The Dbus object path
227 * @param[in] dbusProp - The property name to get
228 * @param[in] dbusInterface - The Dbus interface
229 *
230 * @return The value of the property(type: variant)
231 *
Patrick Williams4fea7a22021-09-02 09:54:12 -0500232 * @throw sdbusplus::exception::exception when it fails
John Wang9e242422020-03-05 08:37:50 +0800233 */
234 PropertyValue
235 getDbusPropertyVariant(const char* objPath, const char* dbusProp,
236 const char* dbusInterface) const override;
George Liu0e02c322020-01-01 09:41:51 +0800237
John Wang9e242422020-03-05 08:37:50 +0800238 /** @brief The template function to get property from the requested dbus
239 * path
240 *
241 * @tparam Property - Excepted type of the property on dbus
242 *
243 * @param[in] objPath - The Dbus object path
244 * @param[in] dbusProp - The property name to get
245 * @param[in] dbusInterface - The Dbus interface
246 *
247 * @return The value of the property
248 *
Patrick Williams4fea7a22021-09-02 09:54:12 -0500249 * @throw sdbusplus::exception::exception when dbus request fails
John Wang9e242422020-03-05 08:37:50 +0800250 * std::bad_variant_access when \p Property and property on dbus do
251 * not match
252 */
John Wang92b3c972019-10-17 11:06:41 +0800253 template <typename Property>
254 auto getDbusProperty(const char* objPath, const char* dbusProp,
255 const char* dbusInterface)
256 {
John Wang9e242422020-03-05 08:37:50 +0800257 auto VariantValue =
258 getDbusPropertyVariant(objPath, dbusProp, dbusInterface);
John Wang92b3c972019-10-17 11:06:41 +0800259 return std::get<Property>(VariantValue);
260 }
George Liu1e44c732020-02-28 20:20:06 +0800261
262 /** @brief Set Dbus property
263 *
264 * @param[in] dBusMap - Object path, property name, interface and property
265 * type for the D-Bus object
266 * @param[in] value - The value to be set
John Wang9e242422020-03-05 08:37:50 +0800267 *
Patrick Williams4fea7a22021-09-02 09:54:12 -0500268 * @throw sdbusplus::exception::exception when it fails
George Liu1e44c732020-02-28 20:20:06 +0800269 */
270 void setDbusProperty(const DBusMapping& dBusMap,
271 const PropertyValue& value) const override;
Sampa Misraa2fa0702019-05-31 01:28:55 -0500272};
273
Deepak Kodihalli3cd61812020-03-10 06:38:45 -0500274/** @brief Fetch parent D-Bus object based on pathname
275 *
276 * @param[in] dbusObj - child D-Bus object
277 *
278 * @return std::string - the parent D-Bus object path
279 */
280inline std::string findParent(const std::string& dbusObj)
281{
282 fs::path p(dbusObj);
283 return p.parent_path().string();
284}
285
Pavithra Barithaya51efaf82020-04-02 02:42:27 -0500286/** @brief Read (static) MCTP EID of host firmware from a file
287 *
288 * @return uint8_t - MCTP EID
289 */
290uint8_t readHostEID();
Tom Joseph250c4752020-04-15 10:32:45 +0530291
TOM JOSEPHd4d97a52020-03-23 14:36:34 +0530292/** @brief Convert a value in the JSON to a D-Bus property value
293 *
294 * @param[in] type - type of the D-Bus property
295 * @param[in] value - value in the JSON file
296 *
297 * @return PropertyValue - the D-Bus property value
298 */
299PropertyValue jsonEntryToDbusVal(std::string_view type,
300 const nlohmann::json& value);
Pavithra Barithaya51efaf82020-04-02 02:42:27 -0500301
Pavithra Barithaya0f74c982020-04-27 02:17:10 -0500302/** @brief Find State Effecter PDR
303 * @param[in] tid - PLDM terminus ID.
304 * @param[in] entityID - entity that can be associated with PLDM State set.
305 * @param[in] stateSetId - value that identifies PLDM State set.
306 * @param[in] repo - pointer to BMC's primary PDR repo.
307 * @return array[array[uint8_t]] - StateEffecterPDRs
308 */
309std::vector<std::vector<uint8_t>> findStateEffecterPDR(uint8_t tid,
310 uint16_t entityID,
311 uint16_t stateSetId,
312 const pldm_pdr* repo);
Chicago Duan738e4d82020-05-28 16:39:19 +0800313/** @brief Find State Sensor PDR
314 * @param[in] tid - PLDM terminus ID.
315 * @param[in] entityID - entity that can be associated with PLDM State set.
316 * @param[in] stateSetId - value that identifies PLDM State set.
317 * @param[in] repo - pointer to BMC's primary PDR repo.
318 * @return array[array[uint8_t]] - StateSensorPDRs
319 */
320std::vector<std::vector<uint8_t>> findStateSensorPDR(uint8_t tid,
321 uint16_t entityID,
322 uint16_t stateSetId,
323 const pldm_pdr* repo);
Pavithra Barithaya0f74c982020-04-27 02:17:10 -0500324
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500325/** @brief Find sensor id from a state sensor PDR
326 *
327 * @param[in] pdrRepo - PDR repository
328 * @param[in] tid - terminus id
329 * @param[in] entityType - entity type
330 * @param[in] entityInstance - entity instance number
331 * @param[in] containerId - container id
332 * @param[in] stateSetId - state set id
333 *
334 * @return uint16_t - the sensor id
335 */
336uint16_t findStateSensorId(const pldm_pdr* pdrRepo, uint8_t tid,
337 uint16_t entityType, uint16_t entityInstance,
338 uint16_t containerId, uint16_t stateSetId);
339
Tom Joseph250c4752020-04-15 10:32:45 +0530340/** @brief Find effecter id from a state effecter pdr
341 * @param[in] pdrRepo - PDR repository
342 * @param[in] entityType - entity type
343 * @param[in] entityInstance - entity instance number
344 * @param[in] containerId - container id
345 * @param[in] stateSetId - state set id
Sampa Misraa4a96162020-07-14 05:33:46 -0500346 * @param[in] localOrRemote - true for checking local repo and false for remote
347 * repo
Tom Joseph250c4752020-04-15 10:32:45 +0530348 *
349 * @return uint16_t - the effecter id
350 */
351uint16_t findStateEffecterId(const pldm_pdr* pdrRepo, uint16_t entityType,
352 uint16_t entityInstance, uint16_t containerId,
Sampa Misraa4a96162020-07-14 05:33:46 -0500353 uint16_t stateSetId, bool localOrRemote);
Tom Joseph250c4752020-04-15 10:32:45 +0530354
Chicago Duanfe4d88b2020-06-12 16:44:13 +0800355/** @brief Emit the sensor event signal
356 *
357 * @param[in] tid - the terminus id
358 * @param[in] sensorId - sensorID value of the sensor
359 * @param[in] sensorOffset - Identifies which state sensor within a
360 * composite state sensor the event is being returned for
361 * @param[in] eventState - The event state value from the state change that
362 * triggered the event message
363 * @param[in] previousEventState - The event state value for the state from
364 * which the present event state was entered.
365 * @return PLDM completion code
366 */
367int emitStateSensorEventSignal(uint8_t tid, uint16_t sensorId,
368 uint8_t sensorOffset, uint8_t eventState,
369 uint8_t previousEventState);
370
Sridevi Rameshae28bc72020-12-10 07:21:16 -0600371/** @brief Print the buffer
372 *
Tom Josephe5268cd2021-09-07 13:04:03 +0530373 * @param[in] isTx - True if the buffer is an outgoing PLDM message, false if
374 the buffer is an incoming PLDM message
375 * @param[in] buffer - Buffer to print
Sridevi Rameshae28bc72020-12-10 07:21:16 -0600376 *
377 * @return - None
378 */
Tom Josephe5268cd2021-09-07 13:04:03 +0530379void printBuffer(bool isTx, const std::vector<uint8_t>& buffer);
Sridevi Rameshae28bc72020-12-10 07:21:16 -0600380
Tom Joseph54922072021-06-19 02:45:46 -0700381/** @brief Convert the buffer to std::string
382 *
383 * If there are characters that are not printable characters, it is replaced
384 * with space(0x20).
385 *
386 * @param[in] var - pointer to data and length of the data
387 *
388 * @return std::string equivalent of variable field
389 */
390std::string toString(const struct variable_field& var);
391
George Liu872f0f62021-11-25 16:26:16 +0800392/** @brief Split strings according to special identifiers
393 *
394 * We can split the string according to the custom identifier(';', ',', '&' or
395 * others) and store it to vector.
396 *
397 * @param[in] srcStr - The string to be split
398 * @param[in] delim - The custom identifier
399 * @param[in] trimStr - The first and last string to be trimmed
400 *
401 * @return std::vector<std::string> Vectors are used to store strings
402 */
403std::vector<std::string> split(std::string_view srcStr, std::string_view delim,
404 std::string_view trimStr = "");
405
George Liu83409572019-12-24 18:42:54 +0800406} // namespace utils
Sampa Misra032bd502019-03-06 05:03:22 -0600407} // namespace pldm