1 #pragma once 2 3 #include "types.hpp" 4 5 #include <libpldm/base.h> 6 #include <libpldm/bios.h> 7 #include <libpldm/entity.h> 8 #include <libpldm/pdr.h> 9 #include <libpldm/platform.h> 10 #include <libpldm/utils.h> 11 #include <stdint.h> 12 #include <systemd/sd-bus.h> 13 #include <unistd.h> 14 15 #include <nlohmann/json.hpp> 16 #include <sdbusplus/server.hpp> 17 #include <xyz/openbmc_project/Inventory/Manager/client.hpp> 18 #include <xyz/openbmc_project/Logging/Entry/server.hpp> 19 #include <xyz/openbmc_project/ObjectMapper/client.hpp> 20 21 #include <deque> 22 #include <exception> 23 #include <filesystem> 24 #include <iostream> 25 #include <map> 26 #include <string> 27 #include <variant> 28 #include <vector> 29 30 constexpr uint64_t dbusTimeout = 31 std::chrono::duration_cast<std::chrono::microseconds>( 32 std::chrono::seconds(DBUS_TIMEOUT)) 33 .count(); 34 35 namespace pldm 36 { 37 namespace utils 38 { 39 namespace fs = std::filesystem; 40 using Json = nlohmann::json; 41 constexpr bool Tx = true; 42 constexpr bool Rx = false; 43 using ObjectMapper = sdbusplus::client::xyz::openbmc_project::ObjectMapper<>; 44 using inventoryManager = 45 sdbusplus::client::xyz::openbmc_project::inventory::Manager<>; 46 47 constexpr auto dbusProperties = "org.freedesktop.DBus.Properties"; 48 constexpr auto mapperService = ObjectMapper::default_service; 49 constexpr auto inventoryPath = "/xyz/openbmc_project/inventory"; 50 /** @struct CustomFD 51 * 52 * RAII wrapper for file descriptor. 53 */ 54 struct CustomFD 55 { 56 CustomFD(const CustomFD&) = delete; 57 CustomFD& operator=(const CustomFD&) = delete; 58 CustomFD(CustomFD&&) = delete; 59 CustomFD& operator=(CustomFD&&) = delete; 60 61 CustomFD(int fd) : fd(fd) {} 62 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 80 /** @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 */ 85 uint8_t getNumPadBytes(uint32_t data); 86 87 /** @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 96 * @return true if decode success, false if decode faild 97 */ 98 bool 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 104 * @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 108 */ 109 std::optional<std::vector<set_effecter_state_field>> 110 parseEffecterData(const std::vector<uint8_t>& effecterData, 111 uint8_t effecterCount); 112 113 /** 114 * @brief creates an error log 115 * @param[in] errorMsg - the error message 116 */ 117 void reportError(const char* errorMsg); 118 119 /** @brief Convert any Decimal number to BCD 120 * 121 * @tparam[in] decimal - Decimal number 122 * @return Corresponding BCD number 123 */ 124 template <typename T> 125 T 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 142 struct 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 150 using PropertyValue = 151 std::variant<bool, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, 152 uint64_t, double, std::string, std::vector<uint8_t>, 153 std::vector<std::string>>; 154 using DbusProp = std::string; 155 using DbusChangedProps = std::map<DbusProp, PropertyValue>; 156 using DBusInterfaceAdded = std::vector< 157 std::pair<pldm::dbus::Interface, 158 std::vector<std::pair<pldm::dbus::Property, 159 std::variant<pldm::dbus::Property>>>>>; 160 using ObjectPath = std::string; 161 using ServiceName = std::string; 162 using Interfaces = std::vector<std::string>; 163 using MapperServiceMap = std::vector<std::pair<ServiceName, Interfaces>>; 164 using GetSubTreeResponse = std::vector<std::pair<ObjectPath, MapperServiceMap>>; 165 using GetSubTreePathsResponse = std::vector<std::string>; 166 using PropertyMap = std::map<std::string, PropertyValue>; 167 using InterfaceMap = std::map<std::string, PropertyMap>; 168 using ObjectValueTree = std::map<sdbusplus::message::object_path, InterfaceMap>; 169 170 /** 171 * @brief The interface for DBusHandler 172 */ 173 class DBusHandlerInterface 174 { 175 public: 176 virtual ~DBusHandlerInterface() = default; 177 178 virtual std::string getService(const char* path, 179 const char* interface) const = 0; 180 virtual GetSubTreeResponse 181 getSubtree(const std::string& path, int depth, 182 const std::vector<std::string>& ifaceList) const = 0; 183 184 virtual GetSubTreePathsResponse 185 getSubTreePaths(const std::string& objectPath, int depth, 186 const std::vector<std::string>& ifaceList) const = 0; 187 188 virtual void setDbusProperty(const DBusMapping& dBusMap, 189 const PropertyValue& value) const = 0; 190 191 virtual PropertyValue 192 getDbusPropertyVariant(const char* objPath, const char* dbusProp, 193 const char* dbusInterface) const = 0; 194 195 virtual PropertyMap 196 getDbusPropertiesVariant(const char* serviceName, const char* objPath, 197 const char* dbusInterface) const = 0; 198 }; 199 200 /** 201 * @class DBusHandler 202 * 203 * Wrapper class to handle the D-Bus calls 204 * 205 * This class contains the APIs to handle the D-Bus calls 206 * to cater the request from pldm requester. 207 * A class is created to mock the apis in the test cases 208 */ 209 class DBusHandler : public DBusHandlerInterface 210 { 211 public: 212 /** @brief Get the bus connection. */ 213 static auto& getBus() 214 { 215 static auto bus = sdbusplus::bus::new_default(); 216 return bus; 217 } 218 219 /** 220 * @brief Get the DBUS Service name for the input dbus path 221 * 222 * @param[in] path - DBUS object path 223 * @param[in] interface - DBUS Interface 224 * 225 * @return std::string - the dbus service name 226 * 227 * @throw sdbusplus::exception_t when it fails 228 */ 229 std::string getService(const char* path, 230 const char* interface) const override; 231 232 /** 233 * @brief Get the Subtree response from the mapper 234 * 235 * @param[in] path - DBUS object path 236 * @param[in] depth - Search depth 237 * @param[in] ifaceList - list of the interface that are being 238 * queried from the mapper 239 * 240 * @return GetSubTreeResponse - the mapper subtree response 241 * 242 * @throw sdbusplus::exception_t when it fails 243 */ 244 GetSubTreeResponse 245 getSubtree(const std::string& path, int depth, 246 const std::vector<std::string>& ifaceList) const override; 247 248 /** @brief Get Subtree path response from the mapper 249 * 250 * @param[in] path - DBUS object path 251 * @param[in] depth - Search depth 252 * @param[in] ifaceList - list of the interface that are being 253 * queried from the mapper 254 * 255 * @return std::vector<std::string> vector of subtree paths 256 */ 257 GetSubTreePathsResponse getSubTreePaths( 258 const std::string& objectPath, int depth, 259 const std::vector<std::string>& ifaceList) const override; 260 261 /** @brief Get property(type: variant) from the requested dbus 262 * 263 * @param[in] objPath - The Dbus object path 264 * @param[in] dbusProp - The property name to get 265 * @param[in] dbusInterface - The Dbus interface 266 * 267 * @return The value of the property(type: variant) 268 * 269 * @throw sdbusplus::exception_t when it fails 270 */ 271 PropertyValue 272 getDbusPropertyVariant(const char* objPath, const char* dbusProp, 273 const char* dbusInterface) const override; 274 275 /** @brief Get All properties(type: variant) from the requested dbus 276 * 277 * @param[in] serviceName - The Dbus service name 278 * @param[in] objPath - The Dbus object path 279 * @param[in] dbusInterface - The Dbus interface 280 * 281 * @return The values of the properties(type: variant) 282 * 283 * @throw sdbusplus::exception_t when it fails 284 */ 285 PropertyMap 286 getDbusPropertiesVariant(const char* serviceName, const char* objPath, 287 const char* dbusInterface) const override; 288 289 /** @brief The template function to get property from the requested dbus 290 * path 291 * 292 * @tparam Property - Excepted type of the property on dbus 293 * 294 * @param[in] objPath - The Dbus object path 295 * @param[in] dbusProp - The property name to get 296 * @param[in] dbusInterface - The Dbus interface 297 * 298 * @return The value of the property 299 * 300 * @throw sdbusplus::exception_t when dbus request fails 301 * std::bad_variant_access when \p Property and property on dbus do 302 * not match 303 */ 304 template <typename Property> 305 auto getDbusProperty(const char* objPath, const char* dbusProp, 306 const char* dbusInterface) 307 { 308 auto VariantValue = getDbusPropertyVariant(objPath, dbusProp, 309 dbusInterface); 310 return std::get<Property>(VariantValue); 311 } 312 313 /** @brief Set Dbus property 314 * 315 * @param[in] dBusMap - Object path, property name, interface and property 316 * type for the D-Bus object 317 * @param[in] value - The value to be set 318 * 319 * @throw sdbusplus::exception_t when it fails 320 */ 321 void setDbusProperty(const DBusMapping& dBusMap, 322 const PropertyValue& value) const override; 323 324 /** @brief This function retrieves the properties of an object managed 325 * by the specified D-Bus service located at the given object path. 326 * 327 * @param[in] service - The D-Bus service providing the managed object 328 * @param[in] value - The object path of the managed object 329 * 330 * @return A hierarchical structure representing the properties of the 331 * managed object. 332 * @throw sdbusplus::exception_t when it fails 333 */ 334 static ObjectValueTree getManagedObj(const char* service, const char* path); 335 336 /** @brief Retrieve the inventory objects managed by a specified class. 337 * The retrieved inventory objects are cached statically 338 * and returned upon subsequent calls to this function. 339 * 340 * @tparam ClassType - The class type that manages the inventory objects. 341 * 342 * @return A reference to the cached inventory objects. 343 */ 344 template <typename ClassType> 345 static auto& getInventoryObjects() 346 { 347 static ObjectValueTree object = ClassType::getManagedObj( 348 inventoryManager::interface, inventoryPath); 349 return object; 350 } 351 }; 352 353 /** @brief Fetch parent D-Bus object based on pathname 354 * 355 * @param[in] dbusObj - child D-Bus object 356 * 357 * @return std::string - the parent D-Bus object path 358 */ 359 inline std::string findParent(const std::string& dbusObj) 360 { 361 fs::path p(dbusObj); 362 return p.parent_path().string(); 363 } 364 365 /** @brief Read (static) MCTP EID of host firmware from a file 366 * 367 * @return uint8_t - MCTP EID 368 */ 369 uint8_t readHostEID(); 370 371 /** @brief Convert a value in the JSON to a D-Bus property value 372 * 373 * @param[in] type - type of the D-Bus property 374 * @param[in] value - value in the JSON file 375 * 376 * @return PropertyValue - the D-Bus property value 377 */ 378 PropertyValue jsonEntryToDbusVal(std::string_view type, 379 const nlohmann::json& value); 380 381 /** @brief Find State Effecter PDR 382 * @param[in] tid - PLDM terminus ID. 383 * @param[in] entityID - entity that can be associated with PLDM State set. 384 * @param[in] stateSetId - value that identifies PLDM State set. 385 * @param[in] repo - pointer to BMC's primary PDR repo. 386 * @return array[array[uint8_t]] - StateEffecterPDRs 387 */ 388 std::vector<std::vector<uint8_t>> findStateEffecterPDR(uint8_t tid, 389 uint16_t entityID, 390 uint16_t stateSetId, 391 const pldm_pdr* repo); 392 /** @brief Find State Sensor PDR 393 * @param[in] tid - PLDM terminus ID. 394 * @param[in] entityID - entity that can be associated with PLDM State set. 395 * @param[in] stateSetId - value that identifies PLDM State set. 396 * @param[in] repo - pointer to BMC's primary PDR repo. 397 * @return array[array[uint8_t]] - StateSensorPDRs 398 */ 399 std::vector<std::vector<uint8_t>> findStateSensorPDR(uint8_t tid, 400 uint16_t entityID, 401 uint16_t stateSetId, 402 const pldm_pdr* repo); 403 404 /** @brief Find sensor id from a state sensor PDR 405 * 406 * @param[in] pdrRepo - PDR repository 407 * @param[in] tid - terminus id 408 * @param[in] entityType - entity type 409 * @param[in] entityInstance - entity instance number 410 * @param[in] containerId - container id 411 * @param[in] stateSetId - state set id 412 * 413 * @return uint16_t - the sensor id 414 */ 415 uint16_t findStateSensorId(const pldm_pdr* pdrRepo, uint8_t tid, 416 uint16_t entityType, uint16_t entityInstance, 417 uint16_t containerId, uint16_t stateSetId); 418 419 /** @brief Find effecter id from a state effecter pdr 420 * @param[in] pdrRepo - PDR repository 421 * @param[in] entityType - entity type 422 * @param[in] entityInstance - entity instance number 423 * @param[in] containerId - container id 424 * @param[in] stateSetId - state set id 425 * @param[in] localOrRemote - true for checking local repo and false for remote 426 * repo 427 * 428 * @return uint16_t - the effecter id 429 */ 430 uint16_t findStateEffecterId(const pldm_pdr* pdrRepo, uint16_t entityType, 431 uint16_t entityInstance, uint16_t containerId, 432 uint16_t stateSetId, bool localOrRemote); 433 434 /** @brief Emit the sensor event signal 435 * 436 * @param[in] tid - the terminus id 437 * @param[in] sensorId - sensorID value of the sensor 438 * @param[in] sensorOffset - Identifies which state sensor within a 439 * composite state sensor the event is being returned for 440 * @param[in] eventState - The event state value from the state change that 441 * triggered the event message 442 * @param[in] previousEventState - The event state value for the state from 443 * which the present event state was entered. 444 * @return PLDM completion code 445 */ 446 int emitStateSensorEventSignal(uint8_t tid, uint16_t sensorId, 447 uint8_t sensorOffset, uint8_t eventState, 448 uint8_t previousEventState); 449 450 /** @brief Print the buffer 451 * 452 * @param[in] isTx - True if the buffer is an outgoing PLDM message, false if 453 the buffer is an incoming PLDM message 454 * @param[in] buffer - Buffer to print 455 * 456 * @return - None 457 */ 458 void printBuffer(bool isTx, const std::vector<uint8_t>& buffer); 459 460 /** @brief Convert the buffer to std::string 461 * 462 * If there are characters that are not printable characters, it is replaced 463 * with space(0x20). 464 * 465 * @param[in] var - pointer to data and length of the data 466 * 467 * @return std::string equivalent of variable field 468 */ 469 std::string toString(const struct variable_field& var); 470 471 /** @brief Split strings according to special identifiers 472 * 473 * We can split the string according to the custom identifier(';', ',', '&' or 474 * others) and store it to vector. 475 * 476 * @param[in] srcStr - The string to be split 477 * @param[in] delim - The custom identifier 478 * @param[in] trimStr - The first and last string to be trimmed 479 * 480 * @return std::vector<std::string> Vectors are used to store strings 481 */ 482 std::vector<std::string> split(std::string_view srcStr, std::string_view delim, 483 std::string_view trimStr = ""); 484 /** @brief Get the current system time in readable format 485 * 486 * @return - std::string equivalent of the system time 487 */ 488 std::string getCurrentSystemTime(); 489 490 /** @brief checks if the FRU is actually present. 491 * @param[in] objPath - FRU object path. 492 * 493 * @return bool to indicate presence or absence of FRU. 494 */ 495 bool checkForFruPresence(const std::string& objPath); 496 497 /** @brief Method to check if the logical bit is set 498 * 499 * @param[containerId] - container id of the entity 500 * 501 * @return true or false based on the logic bit set 502 */ 503 bool checkIfLogicalBitSet(const uint16_t& containerId); 504 505 /** @brief setting the present property 506 * 507 * @param[in] objPath - the object path of the fru 508 * @param[in] present - status to set either true/false 509 */ 510 void setFruPresence(const std::string& fruObjPath, bool present); 511 } // namespace utils 512 } // namespace pldm 513