blob: 6b8ea7caf3ac54da2ba6e90ef40fd5bf9a9fe5ce [file] [log] [blame]
Sampa Misra032bd502019-03-06 05:03:22 -06001#pragma once
2
Sampa Misraaea5dde2020-08-31 08:33:47 -05003#include "types.hpp"
4
George Liuc453e162022-12-21 17:16:23 +08005#include <libpldm/base.h>
6#include <libpldm/bios.h>
George Liudf9a6d32020-12-22 16:27:16 +08007#include <libpldm/entity.h>
8#include <libpldm/pdr.h>
George Liuc453e162022-12-21 17:16:23 +08009#include <libpldm/platform.h>
10#include <libpldm/utils.h>
Sampa Misra032bd502019-03-06 05:03:22 -060011#include <stdint.h>
12#include <systemd/sd-bus.h>
Jinu Joy Thomasf666db12019-05-29 05:22:31 -050013#include <unistd.h>
Sampa Misra032bd502019-03-06 05:03:22 -060014
George Liu6492f522020-06-16 10:34:05 +080015#include <nlohmann/json.hpp>
16#include <sdbusplus/server.hpp>
Riya Dixit754041d2024-02-20 06:15:49 -060017#include <xyz/openbmc_project/Inventory/Manager/client.hpp>
George Liu6492f522020-06-16 10:34:05 +080018#include <xyz/openbmc_project/Logging/Entry/server.hpp>
Gilbert Chen44524a52022-02-14 12:12:25 +000019#include <xyz/openbmc_project/ObjectMapper/client.hpp>
George Liu6492f522020-06-16 10:34:05 +080020
George Liudf9a6d32020-12-22 16:27:16 +080021#include <deque>
Sampa Misraa2fa0702019-05-31 01:28:55 -050022#include <exception>
Deepak Kodihalli3cd61812020-03-10 06:38:45 -050023#include <filesystem>
Sampa Misraaa8ae722019-12-12 03:20:40 -060024#include <iostream>
George Liudf9a6d32020-12-22 16:27:16 +080025#include <map>
Sampa Misra032bd502019-03-06 05:03:22 -060026#include <string>
Sampa Misraa2fa0702019-05-31 01:28:55 -050027#include <variant>
28#include <vector>
Sampa Misra032bd502019-03-06 05:03:22 -060029
vkaverap@in.ibm.com5b71b862023-08-21 05:19:04 +000030constexpr uint64_t dbusTimeout =
31 std::chrono::duration_cast<std::chrono::microseconds>(
32 std::chrono::seconds(DBUS_TIMEOUT))
33 .count();
34
Sampa Misra032bd502019-03-06 05:03:22 -060035namespace pldm
36{
Jinu Joy Thomasf666db12019-05-29 05:22:31 -050037namespace utils
38{
Deepak Kodihalli3cd61812020-03-10 06:38:45 -050039namespace fs = std::filesystem;
Tom Joseph250c4752020-04-15 10:32:45 +053040using Json = nlohmann::json;
Tom Josephe5268cd2021-09-07 13:04:03 +053041constexpr bool Tx = true;
42constexpr bool Rx = false;
Gilbert Chen44524a52022-02-14 12:12:25 +000043using ObjectMapper = sdbusplus::client::xyz::openbmc_project::ObjectMapper<>;
Gilbert Chen44524a52022-02-14 12:12:25 +000044using inventoryManager =
45 sdbusplus::client::xyz::openbmc_project::inventory::Manager<>;
46
47constexpr auto dbusProperties = "org.freedesktop.DBus.Properties";
48constexpr auto mapperService = ObjectMapper::default_service;
49constexpr auto inventoryPath = "/xyz/openbmc_project/inventory";
Jinu Joy Thomasf666db12019-05-29 05:22:31 -050050/** @struct CustomFD
51 *
52 * RAII wrapper for file descriptor.
53 */
54struct CustomFD
55{
56 CustomFD(const CustomFD&) = delete;
57 CustomFD& operator=(const CustomFD&) = delete;
58 CustomFD(CustomFD&&) = delete;
59 CustomFD& operator=(CustomFD&&) = delete;
60
Patrick Williams6da4f912023-05-10 07:50:53 -050061 CustomFD(int fd) : fd(fd) {}
Jinu Joy Thomasf666db12019-05-29 05:22:31 -050062
63 ~CustomFD()
64 {
65 if (fd >= 0)
66 {
67 close(fd);
68 }
69 }
70
71 int operator()() const
72 {
73 return fd;
74 }
75
76 private:
77 int fd = -1;
78};
79
Sampa Misrab37be312019-07-03 02:26:41 -050080/** @brief Calculate the pad for PLDM data
81 *
82 * @param[in] data - Length of the data
83 * @return - uint8_t - number of pad bytes
84 */
85uint8_t getNumPadBytes(uint32_t data);
86
George Liu83409572019-12-24 18:42:54 +080087/** @brief Convert uint64 to date
88 *
89 * @param[in] data - time date of uint64
90 * @param[out] year - year number in dec
91 * @param[out] month - month number in dec
92 * @param[out] day - day of the month in dec
93 * @param[out] hour - number of hours in dec
94 * @param[out] min - number of minutes in dec
95 * @param[out] sec - number of seconds in dec
Manojkiran Eda2576aec2024-06-17 12:05:17 +053096 * @return true if decode success, false if decode failed
George Liu83409572019-12-24 18:42:54 +080097 */
98bool uintToDate(uint64_t data, uint16_t* year, uint8_t* month, uint8_t* day,
99 uint8_t* hour, uint8_t* min, uint8_t* sec);
100
101/** @brief Convert effecter data to structure of set_effecter_state_field
102 *
103 * @param[in] effecterData - the date of effecter
George Liuba4c1fb2020-02-05 14:13:30 +0800104 * @param[in] effecterCount - the number of individual sets of effecter
105 * information
106 * @return[out] parse success and get a valid set_effecter_state_field
107 * structure, return nullopt means parse failed
George Liu83409572019-12-24 18:42:54 +0800108 */
George Liuba4c1fb2020-02-05 14:13:30 +0800109std::optional<std::vector<set_effecter_state_field>>
110 parseEffecterData(const std::vector<uint8_t>& effecterData,
111 uint8_t effecterCount);
Sampa Misra032bd502019-03-06 05:03:22 -0600112
113/**
Sampa Misraaa8ae722019-12-12 03:20:40 -0600114 * @brief creates an error log
115 * @param[in] errorMsg - the error message
116 */
Manojkiran Eda92fb0b52024-04-17 10:48:17 +0530117void reportError(const char* errorMsg);
Sampa Misraaa8ae722019-12-12 03:20:40 -0600118
Sampa Misra032bd502019-03-06 05:03:22 -0600119/** @brief Convert any Decimal number to BCD
120 *
121 * @tparam[in] decimal - Decimal number
122 * @return Corresponding BCD number
123 */
124template <typename T>
125T decimalToBcd(T decimal)
126{
127 T bcd = 0;
128 T rem = 0;
129 auto cnt = 0;
130
131 while (decimal)
132 {
133 rem = decimal % 10;
134 bcd = bcd + (rem << cnt);
135 decimal = decimal / 10;
136 cnt += 4;
137 }
138
139 return bcd;
140}
141
George Liu1e44c732020-02-28 20:20:06 +0800142struct DBusMapping
143{
144 std::string objectPath; //!< D-Bus object path
145 std::string interface; //!< D-Bus interface
146 std::string propertyName; //!< D-Bus property name
147 std::string propertyType; //!< D-Bus property type
148};
149
150using PropertyValue =
151 std::variant<bool, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t,
Riya Dixit754041d2024-02-20 06:15:49 -0600152 uint64_t, double, std::string, std::vector<uint8_t>,
153 std::vector<std::string>>;
Deepak Kodihalli6b1d1ca2020-04-27 07:24:51 -0500154using DbusProp = std::string;
155using DbusChangedProps = std::map<DbusProp, PropertyValue>;
Sampa Misraaea5dde2020-08-31 08:33:47 -0500156using DBusInterfaceAdded = std::vector<
157 std::pair<pldm::dbus::Interface,
158 std::vector<std::pair<pldm::dbus::Property,
159 std::variant<pldm::dbus::Property>>>>>;
Kamalkumar Patel7d427f12024-05-16 03:44:00 -0500160
Manojkiran Eda1ef62c32021-04-24 07:23:18 +0530161using ObjectPath = std::string;
Kamalkumar Patel7d427f12024-05-16 03:44:00 -0500162using EntityName = std::string;
163using Entities = std::vector<pldm_entity_node*>;
164using EntityAssociations = std::vector<Entities>;
165using ObjectPathMaps = std::map<fs::path, pldm_entity_node*>;
166using EntityMaps = std::map<pldm::pdr::EntityType, EntityName>;
167
Manojkiran Eda1ef62c32021-04-24 07:23:18 +0530168using ServiceName = std::string;
169using Interfaces = std::vector<std::string>;
170using MapperServiceMap = std::vector<std::pair<ServiceName, Interfaces>>;
171using GetSubTreeResponse = std::vector<std::pair<ObjectPath, MapperServiceMap>>;
Pavithra Barithaya2ec82692024-04-29 06:31:10 -0500172using GetSubTreePathsResponse = std::vector<std::string>;
Sridevi Ramesheefe49b2022-06-27 11:51:02 -0500173using PropertyMap = std::map<std::string, PropertyValue>;
174using InterfaceMap = std::map<std::string, PropertyMap>;
Riya Dixit754041d2024-02-20 06:15:49 -0600175using ObjectValueTree = std::map<sdbusplus::message::object_path, InterfaceMap>;
George Liu1e44c732020-02-28 20:20:06 +0800176
177/**
178 * @brief The interface for DBusHandler
179 */
180class DBusHandlerInterface
181{
182 public:
183 virtual ~DBusHandlerInterface() = default;
184
George Liu36e81352020-07-01 14:40:30 +0800185 virtual std::string getService(const char* path,
186 const char* interface) const = 0;
Manojkiran Eda1ef62c32021-04-24 07:23:18 +0530187 virtual GetSubTreeResponse
188 getSubtree(const std::string& path, int depth,
189 const std::vector<std::string>& ifaceList) const = 0;
George Liu36e81352020-07-01 14:40:30 +0800190
Pavithra Barithaya2ec82692024-04-29 06:31:10 -0500191 virtual GetSubTreePathsResponse
192 getSubTreePaths(const std::string& objectPath, int depth,
193 const std::vector<std::string>& ifaceList) const = 0;
194
George Liu1e44c732020-02-28 20:20:06 +0800195 virtual void setDbusProperty(const DBusMapping& dBusMap,
196 const PropertyValue& value) const = 0;
John Wang9e242422020-03-05 08:37:50 +0800197
198 virtual PropertyValue
199 getDbusPropertyVariant(const char* objPath, const char* dbusProp,
200 const char* dbusInterface) const = 0;
Gilbert Chen44524a52022-02-14 12:12:25 +0000201
202 virtual PropertyMap
203 getDbusPropertiesVariant(const char* serviceName, const char* objPath,
204 const char* dbusInterface) const = 0;
George Liu1e44c732020-02-28 20:20:06 +0800205};
206
Sampa Misraa2fa0702019-05-31 01:28:55 -0500207/**
208 * @class DBusHandler
209 *
210 * Wrapper class to handle the D-Bus calls
211 *
212 * This class contains the APIs to handle the D-Bus calls
213 * to cater the request from pldm requester.
214 * A class is created to mock the apis in the test cases
215 */
George Liu1e44c732020-02-28 20:20:06 +0800216class DBusHandler : public DBusHandlerInterface
Sampa Misraa2fa0702019-05-31 01:28:55 -0500217{
218 public:
George Liu0e02c322020-01-01 09:41:51 +0800219 /** @brief Get the bus connection. */
220 static auto& getBus()
221 {
222 static auto bus = sdbusplus::bus::new_default();
223 return bus;
224 }
225
226 /**
227 * @brief Get the DBUS Service name for the input dbus path
John Wang9e242422020-03-05 08:37:50 +0800228 *
George Liu0e02c322020-01-01 09:41:51 +0800229 * @param[in] path - DBUS object path
230 * @param[in] interface - DBUS Interface
John Wang9e242422020-03-05 08:37:50 +0800231 *
George Liu0e02c322020-01-01 09:41:51 +0800232 * @return std::string - the dbus service name
John Wang9e242422020-03-05 08:37:50 +0800233 *
Patrick Williams84b790c2022-07-22 19:26:56 -0500234 * @throw sdbusplus::exception_t when it fails
George Liu0e02c322020-01-01 09:41:51 +0800235 */
George Liu36e81352020-07-01 14:40:30 +0800236 std::string getService(const char* path,
237 const char* interface) const override;
George Liu0e02c322020-01-01 09:41:51 +0800238
Manojkiran Eda1ef62c32021-04-24 07:23:18 +0530239 /**
240 * @brief Get the Subtree response from the mapper
241 *
242 * @param[in] path - DBUS object path
243 * @param[in] depth - Search depth
244 * @param[in] ifaceList - list of the interface that are being
245 * queried from the mapper
246 *
247 * @return GetSubTreeResponse - the mapper subtree response
248 *
Patrick Williams84b790c2022-07-22 19:26:56 -0500249 * @throw sdbusplus::exception_t when it fails
Manojkiran Eda1ef62c32021-04-24 07:23:18 +0530250 */
251 GetSubTreeResponse
252 getSubtree(const std::string& path, int depth,
253 const std::vector<std::string>& ifaceList) const override;
254
Pavithra Barithaya2ec82692024-04-29 06:31:10 -0500255 /** @brief Get Subtree path response from the mapper
256 *
257 * @param[in] path - DBUS object path
258 * @param[in] depth - Search depth
259 * @param[in] ifaceList - list of the interface that are being
260 * queried from the mapper
261 *
262 * @return std::vector<std::string> vector of subtree paths
263 */
264 GetSubTreePathsResponse getSubTreePaths(
265 const std::string& objectPath, int depth,
266 const std::vector<std::string>& ifaceList) const override;
267
John Wang9e242422020-03-05 08:37:50 +0800268 /** @brief Get property(type: variant) from the requested dbus
269 *
270 * @param[in] objPath - The Dbus object path
271 * @param[in] dbusProp - The property name to get
272 * @param[in] dbusInterface - The Dbus interface
273 *
274 * @return The value of the property(type: variant)
275 *
Patrick Williams84b790c2022-07-22 19:26:56 -0500276 * @throw sdbusplus::exception_t when it fails
John Wang9e242422020-03-05 08:37:50 +0800277 */
278 PropertyValue
279 getDbusPropertyVariant(const char* objPath, const char* dbusProp,
280 const char* dbusInterface) const override;
George Liu0e02c322020-01-01 09:41:51 +0800281
Gilbert Chen44524a52022-02-14 12:12:25 +0000282 /** @brief Get All properties(type: variant) from the requested dbus
283 *
284 * @param[in] serviceName - The Dbus service name
285 * @param[in] objPath - The Dbus object path
286 * @param[in] dbusInterface - The Dbus interface
287 *
288 * @return The values of the properties(type: variant)
289 *
290 * @throw sdbusplus::exception_t when it fails
291 */
292 PropertyMap
293 getDbusPropertiesVariant(const char* serviceName, const char* objPath,
294 const char* dbusInterface) const override;
295
John Wang9e242422020-03-05 08:37:50 +0800296 /** @brief The template function to get property from the requested dbus
297 * path
298 *
299 * @tparam Property - Excepted type of the property on dbus
300 *
301 * @param[in] objPath - The Dbus object path
302 * @param[in] dbusProp - The property name to get
303 * @param[in] dbusInterface - The Dbus interface
304 *
305 * @return The value of the property
306 *
Patrick Williams84b790c2022-07-22 19:26:56 -0500307 * @throw sdbusplus::exception_t when dbus request fails
John Wang9e242422020-03-05 08:37:50 +0800308 * std::bad_variant_access when \p Property and property on dbus do
309 * not match
310 */
John Wang92b3c972019-10-17 11:06:41 +0800311 template <typename Property>
312 auto getDbusProperty(const char* objPath, const char* dbusProp,
313 const char* dbusInterface)
314 {
Patrick Williams6da4f912023-05-10 07:50:53 -0500315 auto VariantValue = getDbusPropertyVariant(objPath, dbusProp,
316 dbusInterface);
John Wang92b3c972019-10-17 11:06:41 +0800317 return std::get<Property>(VariantValue);
318 }
George Liu1e44c732020-02-28 20:20:06 +0800319
320 /** @brief Set Dbus property
321 *
322 * @param[in] dBusMap - Object path, property name, interface and property
323 * type for the D-Bus object
324 * @param[in] value - The value to be set
John Wang9e242422020-03-05 08:37:50 +0800325 *
Patrick Williams84b790c2022-07-22 19:26:56 -0500326 * @throw sdbusplus::exception_t when it fails
George Liu1e44c732020-02-28 20:20:06 +0800327 */
328 void setDbusProperty(const DBusMapping& dBusMap,
329 const PropertyValue& value) const override;
Riya Dixit754041d2024-02-20 06:15:49 -0600330
331 /** @brief This function retrieves the properties of an object managed
332 * by the specified D-Bus service located at the given object path.
333 *
334 * @param[in] service - The D-Bus service providing the managed object
335 * @param[in] value - The object path of the managed object
336 *
337 * @return A hierarchical structure representing the properties of the
338 * managed object.
Patrick Williams897b0f82024-04-14 02:31:48 -0500339 * @throw sdbusplus::exception_t when it fails
Riya Dixit754041d2024-02-20 06:15:49 -0600340 */
341 static ObjectValueTree getManagedObj(const char* service, const char* path);
342
343 /** @brief Retrieve the inventory objects managed by a specified class.
344 * The retrieved inventory objects are cached statically
345 * and returned upon subsequent calls to this function.
346 *
347 * @tparam ClassType - The class type that manages the inventory objects.
348 *
349 * @return A reference to the cached inventory objects.
350 */
351 template <typename ClassType>
352 static auto& getInventoryObjects()
353 {
354 static ObjectValueTree object = ClassType::getManagedObj(
355 inventoryManager::interface, inventoryPath);
356 return object;
357 }
Sampa Misraa2fa0702019-05-31 01:28:55 -0500358};
359
Deepak Kodihalli3cd61812020-03-10 06:38:45 -0500360/** @brief Fetch parent D-Bus object based on pathname
361 *
362 * @param[in] dbusObj - child D-Bus object
363 *
364 * @return std::string - the parent D-Bus object path
365 */
366inline std::string findParent(const std::string& dbusObj)
367{
368 fs::path p(dbusObj);
369 return p.parent_path().string();
370}
371
Pavithra Barithaya51efaf82020-04-02 02:42:27 -0500372/** @brief Read (static) MCTP EID of host firmware from a file
373 *
374 * @return uint8_t - MCTP EID
375 */
376uint8_t readHostEID();
Tom Joseph250c4752020-04-15 10:32:45 +0530377
Gilbert Chen6c7fed42022-02-22 15:40:17 +0000378/** @brief Validate the MCTP EID of MCTP endpoint
379 * In `Table 2 - Special endpoint IDs` of DSP0236. EID 0 is NULL_EID.
380 * EID from 1 to 7 is reserved EID. EID 0xFF is broadcast EID.
381 * Those are invalid EID of one MCTP Endpoint.
382 *
383 * @param[in] eid - MCTP EID
384 *
385 * @return true if the MCTP EID is valid otherwise return false.
386 */
387bool isValidEID(eid mctpEid);
388
TOM JOSEPHd4d97a52020-03-23 14:36:34 +0530389/** @brief Convert a value in the JSON to a D-Bus property value
390 *
391 * @param[in] type - type of the D-Bus property
392 * @param[in] value - value in the JSON file
393 *
394 * @return PropertyValue - the D-Bus property value
395 */
396PropertyValue jsonEntryToDbusVal(std::string_view type,
397 const nlohmann::json& value);
Pavithra Barithaya51efaf82020-04-02 02:42:27 -0500398
Pavithra Barithaya0f74c982020-04-27 02:17:10 -0500399/** @brief Find State Effecter PDR
400 * @param[in] tid - PLDM terminus ID.
401 * @param[in] entityID - entity that can be associated with PLDM State set.
402 * @param[in] stateSetId - value that identifies PLDM State set.
403 * @param[in] repo - pointer to BMC's primary PDR repo.
404 * @return array[array[uint8_t]] - StateEffecterPDRs
405 */
406std::vector<std::vector<uint8_t>> findStateEffecterPDR(uint8_t tid,
407 uint16_t entityID,
408 uint16_t stateSetId,
409 const pldm_pdr* repo);
Chicago Duan738e4d82020-05-28 16:39:19 +0800410/** @brief Find State Sensor PDR
411 * @param[in] tid - PLDM terminus ID.
412 * @param[in] entityID - entity that can be associated with PLDM State set.
413 * @param[in] stateSetId - value that identifies PLDM State set.
414 * @param[in] repo - pointer to BMC's primary PDR repo.
415 * @return array[array[uint8_t]] - StateSensorPDRs
416 */
417std::vector<std::vector<uint8_t>> findStateSensorPDR(uint8_t tid,
418 uint16_t entityID,
419 uint16_t stateSetId,
420 const pldm_pdr* repo);
Pavithra Barithaya0f74c982020-04-27 02:17:10 -0500421
Sampa Misra3a0e3b92020-10-21 05:58:00 -0500422/** @brief Find sensor id from a state sensor PDR
423 *
424 * @param[in] pdrRepo - PDR repository
425 * @param[in] tid - terminus id
426 * @param[in] entityType - entity type
427 * @param[in] entityInstance - entity instance number
428 * @param[in] containerId - container id
429 * @param[in] stateSetId - state set id
430 *
431 * @return uint16_t - the sensor id
432 */
433uint16_t findStateSensorId(const pldm_pdr* pdrRepo, uint8_t tid,
434 uint16_t entityType, uint16_t entityInstance,
435 uint16_t containerId, uint16_t stateSetId);
436
Tom Joseph250c4752020-04-15 10:32:45 +0530437/** @brief Find effecter id from a state effecter pdr
438 * @param[in] pdrRepo - PDR repository
439 * @param[in] entityType - entity type
440 * @param[in] entityInstance - entity instance number
441 * @param[in] containerId - container id
442 * @param[in] stateSetId - state set id
Sampa Misraa4a96162020-07-14 05:33:46 -0500443 * @param[in] localOrRemote - true for checking local repo and false for remote
444 * repo
Tom Joseph250c4752020-04-15 10:32:45 +0530445 *
446 * @return uint16_t - the effecter id
447 */
448uint16_t findStateEffecterId(const pldm_pdr* pdrRepo, uint16_t entityType,
449 uint16_t entityInstance, uint16_t containerId,
Sampa Misraa4a96162020-07-14 05:33:46 -0500450 uint16_t stateSetId, bool localOrRemote);
Tom Joseph250c4752020-04-15 10:32:45 +0530451
Chicago Duanfe4d88b2020-06-12 16:44:13 +0800452/** @brief Emit the sensor event signal
453 *
454 * @param[in] tid - the terminus id
455 * @param[in] sensorId - sensorID value of the sensor
456 * @param[in] sensorOffset - Identifies which state sensor within a
457 * composite state sensor the event is being returned for
458 * @param[in] eventState - The event state value from the state change that
459 * triggered the event message
460 * @param[in] previousEventState - The event state value for the state from
461 * which the present event state was entered.
462 * @return PLDM completion code
463 */
464int emitStateSensorEventSignal(uint8_t tid, uint16_t sensorId,
465 uint8_t sensorOffset, uint8_t eventState,
466 uint8_t previousEventState);
467
Sridevi Rameshae28bc72020-12-10 07:21:16 -0600468/** @brief Print the buffer
469 *
Tom Josephe5268cd2021-09-07 13:04:03 +0530470 * @param[in] isTx - True if the buffer is an outgoing PLDM message, false if
471 the buffer is an incoming PLDM message
472 * @param[in] buffer - Buffer to print
Sridevi Rameshae28bc72020-12-10 07:21:16 -0600473 *
474 * @return - None
475 */
Tom Josephe5268cd2021-09-07 13:04:03 +0530476void printBuffer(bool isTx, const std::vector<uint8_t>& buffer);
Sridevi Rameshae28bc72020-12-10 07:21:16 -0600477
Tom Joseph54922072021-06-19 02:45:46 -0700478/** @brief Convert the buffer to std::string
479 *
480 * If there are characters that are not printable characters, it is replaced
481 * with space(0x20).
482 *
483 * @param[in] var - pointer to data and length of the data
484 *
485 * @return std::string equivalent of variable field
486 */
487std::string toString(const struct variable_field& var);
488
George Liu872f0f62021-11-25 16:26:16 +0800489/** @brief Split strings according to special identifiers
490 *
491 * We can split the string according to the custom identifier(';', ',', '&' or
492 * others) and store it to vector.
493 *
494 * @param[in] srcStr - The string to be split
495 * @param[in] delim - The custom identifier
496 * @param[in] trimStr - The first and last string to be trimmed
497 *
498 * @return std::vector<std::string> Vectors are used to store strings
499 */
500std::vector<std::string> split(std::string_view srcStr, std::string_view delim,
501 std::string_view trimStr = "");
Manojkiran Edaef773052021-07-29 09:29:28 +0530502/** @brief Get the current system time in readable format
503 *
504 * @return - std::string equivalent of the system time
505 */
506std::string getCurrentSystemTime();
George Liu872f0f62021-11-25 16:26:16 +0800507
Sridevi Ramesheefe49b2022-06-27 11:51:02 -0500508/** @brief checks if the FRU is actually present.
509 * @param[in] objPath - FRU object path.
510 *
511 * @return bool to indicate presence or absence of FRU.
512 */
513bool checkForFruPresence(const std::string& objPath);
514
Sagar Srinivas5db6e872023-12-01 10:03:30 -0600515/** @brief Method to check if the logical bit is set
516 *
517 * @param[containerId] - container id of the entity
518 *
519 * @return true or false based on the logic bit set
520 */
521bool checkIfLogicalBitSet(const uint16_t& containerId);
Pavithra Barithaya5e542be2021-08-13 00:33:31 -0500522
523/** @brief setting the present property
524 *
525 * @param[in] objPath - the object path of the fru
526 * @param[in] present - status to set either true/false
527 */
528void setFruPresence(const std::string& fruObjPath, bool present);
Thu Nguyenb8cf46b2024-06-15 02:44:35 +0000529
530/** @brief Trim `\0` in string and replace ` ` by `_` to use name in D-Bus
531 * object path
532 *
533 * @param[in] name - the input string
534 *
535 * @return the result string
536 */
537std::string_view trimNameForDbus(std::string& name);
538
George Liu83409572019-12-24 18:42:54 +0800539} // namespace utils
Sampa Misra032bd502019-03-06 05:03:22 -0600540} // namespace pldm