1 #include "common/types.hpp"
2 #include "pldm_cmd_helper.hpp"
3 
4 #include <libpldm/entity.h>
5 #include <libpldm/platform.h>
6 #include <libpldm/state_set.h>
7 
8 #include <algorithm>
9 #include <cstddef>
10 #include <map>
11 #include <ranges>
12 
13 #ifdef OEM_IBM
14 #include "oem/ibm/oem_ibm_state_set.hpp"
15 #endif
16 
17 using namespace pldm::utils;
18 
19 namespace pldmtool
20 {
21 namespace platform
22 {
23 namespace
24 {
25 using namespace pldmtool::helper;
26 
27 static const std::map<uint8_t, std::string> sensorPresState{
28     {PLDM_SENSOR_UNKNOWN, "Sensor Unknown"},
29     {PLDM_SENSOR_NORMAL, "Sensor Normal"},
30     {PLDM_SENSOR_WARNING, "Sensor Warning"},
31     {PLDM_SENSOR_CRITICAL, "Sensor Critical"},
32     {PLDM_SENSOR_FATAL, "Sensor Fatal"},
33     {PLDM_SENSOR_LOWERWARNING, "Sensor Lower Warning"},
34     {PLDM_SENSOR_LOWERCRITICAL, "Sensor Lower Critical"},
35     {PLDM_SENSOR_LOWERFATAL, "Sensor Lower Fatal"},
36     {PLDM_SENSOR_UPPERWARNING, "Sensor Upper Warning"},
37     {PLDM_SENSOR_UPPERCRITICAL, "Sensor Upper Critical"},
38     {PLDM_SENSOR_UPPERFATAL, "Sensor Upper Fatal"}};
39 
40 static const std::map<uint8_t, std::string> sensorOpState{
41     {PLDM_SENSOR_ENABLED, "Sensor Enabled"},
42     {PLDM_SENSOR_DISABLED, "Sensor Disabled"},
43     {PLDM_SENSOR_UNAVAILABLE, "Sensor Unavailable"},
44     {PLDM_SENSOR_STATUSUNKOWN, "Sensor Status Unknown"},
45     {PLDM_SENSOR_FAILED, "Sensor Failed"},
46     {PLDM_SENSOR_INITIALIZING, "Sensor Sensor Intializing"},
47     {PLDM_SENSOR_SHUTTINGDOWN, "Sensor Shutting down"},
48     {PLDM_SENSOR_INTEST, "Sensor Intest"}};
49 
50 std::vector<std::unique_ptr<CommandInterface>> commands;
51 
52 } // namespace
53 
54 using ordered_json = nlohmann::ordered_json;
55 
56 class GetPDR : public CommandInterface
57 {
58   public:
59     ~GetPDR() = default;
60     GetPDR() = delete;
61     GetPDR(const GetPDR&) = delete;
62     GetPDR(GetPDR&&) = default;
63     GetPDR& operator=(const GetPDR&) = delete;
64     GetPDR& operator=(GetPDR&&) = delete;
65 
66     using CommandInterface::CommandInterface;
67 
68     explicit GetPDR(const char* type, const char* name, CLI::App* app) :
69         CommandInterface(type, name, app)
70     {
71         auto pdrOptionGroup = app->add_option_group(
72             "Required Option",
73             "Retrieve individual PDR, all PDRs, PDRs of a requested type or retrieve all PDRs of the requested terminusID");
74         pdrOptionGroup->add_option(
75             "-d,--data", recordHandle,
76             "retrieve individual PDRs from a PDR Repository\n"
77             "eg: The recordHandle value for the PDR to be retrieved and 0 "
78             "means get first PDR in the repository.");
79         pdrRecType = "";
80         pdrOptionGroup->add_option("-t, --type", pdrRecType,
81                                    "retrieve all PDRs of the requested type\n"
82                                    "supported types:\n"
83                                    "[terminusLocator, stateSensor, "
84                                    "numericEffecter, stateEffecter, "
85                                    "compactNumericSensor, sensorauxname, "
86                                    "efffecterAuxName, numericsensor, "
87                                    "EntityAssociation, fruRecord, ... ]");
88 
89         getPDRGroupOption = pdrOptionGroup->add_option(
90             "-i, --terminusID", pdrTerminus,
91             "retrieve all PDRs of the requested terminusID\n"
92             "supported IDs:\n [1, 2, 208...]");
93 
94         allPDRs = false;
95         pdrOptionGroup->add_flag("-a, --all", allPDRs,
96                                  "retrieve all PDRs from a PDR repository");
97 
98         pdrOptionGroup->require_option(1);
99     }
100 
101     void parseGetPDROptions()
102     {
103         optTIDSet = false;
104         if (getPDRGroupOption->count() > 0)
105         {
106             optTIDSet = true;
107             getPDRs();
108         }
109     }
110 
111     void getPDRs()
112     {
113         // start the array
114         std::cout << "[";
115 
116         recordHandle = 0;
117         do
118         {
119             CommandInterface::exec();
120         } while (recordHandle != 0);
121 
122         // close the array
123         std::cout << "]\n";
124 
125         if (handleFound)
126         {
127             recordHandle = 0;
128             uint32_t prevRecordHandle = 0;
129             do
130             {
131                 CommandInterface::exec();
132                 if (recordHandle == prevRecordHandle)
133                 {
134                     return;
135                 }
136                 prevRecordHandle = recordHandle;
137             } while (recordHandle != 0);
138         }
139     }
140 
141     void exec() override
142     {
143         if (allPDRs || !pdrRecType.empty())
144         {
145             if (!pdrRecType.empty())
146             {
147                 std::transform(pdrRecType.begin(), pdrRecType.end(),
148                                pdrRecType.begin(), tolower);
149             }
150 
151             // start the array
152             std::cout << "[\n";
153 
154             // Retrieve all PDR records starting from the first
155             recordHandle = 0;
156             uint32_t prevRecordHandle = 0;
157             std::map<uint32_t, uint32_t> recordsSeen;
158             do
159             {
160                 CommandInterface::exec();
161                 // recordHandle is updated to nextRecord when
162                 // CommandInterface::exec() is successful.
163                 // In case of any error, return.
164                 if (recordHandle == prevRecordHandle)
165                 {
166                     return;
167                 }
168 
169                 // check for circular references.
170                 auto result = recordsSeen.emplace(recordHandle,
171                                                   prevRecordHandle);
172                 if (!result.second)
173                 {
174                     std::cerr
175                         << "Record handle " << recordHandle
176                         << " has multiple references: " << result.first->second
177                         << ", " << prevRecordHandle << "\n";
178                     return;
179                 }
180                 prevRecordHandle = recordHandle;
181 
182                 if (recordHandle != 0)
183                 {
184                     // close the array
185                     std::cout << ",";
186                 }
187             } while (recordHandle != 0);
188 
189             // close the array
190             std::cout << "]\n";
191         }
192         else
193         {
194             CommandInterface::exec();
195         }
196     }
197 
198     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
199     {
200         std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
201                                         PLDM_GET_PDR_REQ_BYTES);
202         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
203 
204         auto rc = encode_get_pdr_req(instanceId, recordHandle, 0,
205                                      PLDM_GET_FIRSTPART, UINT16_MAX, 0, request,
206                                      PLDM_GET_PDR_REQ_BYTES);
207         return {rc, requestMsg};
208     }
209 
210     void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
211     {
212         uint8_t completionCode = 0;
213         uint8_t recordData[UINT16_MAX] = {0};
214         uint32_t nextRecordHndl = 0;
215         uint32_t nextDataTransferHndl = 0;
216         uint8_t transferFlag = 0;
217         uint16_t respCnt = 0;
218         uint8_t transferCRC = 0;
219 
220         auto rc = decode_get_pdr_resp(
221             responsePtr, payloadLength, &completionCode, &nextRecordHndl,
222             &nextDataTransferHndl, &transferFlag, &respCnt, recordData,
223             sizeof(recordData), &transferCRC);
224 
225         if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
226         {
227             std::cerr << "Response Message Error: "
228                       << "rc=" << rc << ",cc=" << (int)completionCode
229                       << std::endl;
230             return;
231         }
232 
233         if (optTIDSet && !handleFound)
234         {
235             terminusHandle = getTerminusHandle(recordData, pdrTerminus);
236             if (terminusHandle.has_value())
237             {
238                 recordHandle = 0;
239                 return;
240             }
241             else
242             {
243                 recordHandle = nextRecordHndl;
244                 return;
245             }
246         }
247 
248         else
249         {
250             printPDRMsg(nextRecordHndl, respCnt, recordData, terminusHandle);
251             recordHandle = nextRecordHndl;
252         }
253     }
254 
255   private:
256     const std::map<pldm::pdr::EntityType, std::string> entityType = {
257         {PLDM_ENTITY_UNSPECIFIED, "Unspecified"},
258         {PLDM_ENTITY_OTHER, "Other"},
259         {PLDM_ENTITY_NETWORK, "Network"},
260         {PLDM_ENTITY_GROUP, "Group"},
261         {PLDM_ENTITY_REMOTE_MGMT_COMM_DEVICE,
262          "Remote Management Communication Device"},
263         {PLDM_ENTITY_EXTERNAL_ENVIRONMENT, "External Environment"},
264         {PLDM_ENTITY_COMM_CHANNEL, " Communication Channel"},
265         {PLDM_ENTITY_TERMINUS, "PLDM Terminus"},
266         {PLDM_ENTITY_PLATFORM_EVENT_LOG, " Platform Event Log"},
267         {PLDM_ENTITY_KEYPAD, "keypad"},
268         {PLDM_ENTITY_SWITCH, "Switch"},
269         {PLDM_ENTITY_PUSHBUTTON, "Pushbutton"},
270         {PLDM_ENTITY_DISPLAY, "Display"},
271         {PLDM_ENTITY_INDICATOR, "Indicator"},
272         {PLDM_ENTITY_SYS_MGMT_SW, "System Management Software"},
273         {PLDM_ENTITY_SYS_FIRMWARE, "System Firmware"},
274         {PLDM_ENTITY_OPERATING_SYS, "Operating System"},
275         {PLDM_ENTITY_VIRTUAL_MACHINE_MANAGER, "Virtual Machine Manager"},
276         {PLDM_ENTITY_OS_LOADER, "OS Loader"},
277         {PLDM_ENTITY_DEVICE_DRIVER, "Device Driver"},
278         {PLDM_ENTITY_MGMT_CONTROLLER_FW, "Management Controller Firmware"},
279         {PLDM_ENTITY_SYSTEM_CHASSIS, "System chassis (main enclosure)"},
280         {PLDM_ENTITY_SUB_CHASSIS, "Sub-chassis"},
281         {PLDM_ENTITY_DISK_DRIVE_BAY, "Disk Drive Bay"},
282         {PLDM_ENTITY_PERIPHERAL_BAY, "Peripheral Bay"},
283         {PLDM_ENTITY_DEVICE_BAY, "Device bay"},
284         {PLDM_ENTITY_DOOR, "Door"},
285         {PLDM_ENTITY_ACCESS_PANEL, "Access Panel"},
286         {PLDM_ENTITY_COVER, "Cover"},
287         {PLDM_ENTITY_BOARD, "Board"},
288         {PLDM_ENTITY_CARD, "Card"},
289         {PLDM_ENTITY_MODULE, "Module"},
290         {PLDM_ENTITY_SYS_MGMT_MODULE, "System management module"},
291         {PLDM_ENTITY_SYS_BOARD, "System Board"},
292         {PLDM_ENTITY_MEMORY_BOARD, "Memory Board"},
293         {PLDM_ENTITY_MEMORY_MODULE, "Memory Module"},
294         {PLDM_ENTITY_PROC_MODULE, "Processor Module"},
295         {PLDM_ENTITY_ADD_IN_CARD, "Add-in Card"},
296         {PLDM_ENTITY_CHASSIS_FRONT_PANEL_BOARD,
297          "Chassis front panel board(control panel)"},
298         {PLDM_ENTITY_BACK_PANEL_BOARD, "Back panel board"},
299         {PLDM_ENTITY_POWER_MGMT, "Power management board"},
300         {PLDM_ENTITY_POWER_SYS_BOARD, "Power system board"},
301         {PLDM_ENTITY_DRIVE_BACKPLANE, "Drive backplane"},
302         {PLDM_ENTITY_SYS_INTERNAL_EXPANSION_BOARD,
303          "System internal expansion board"},
304         {PLDM_ENTITY_OTHER_SYS_BOARD, "Other system board"},
305         {PLDM_ENTITY_CHASSIS_BACK_PANEL_BOARD, "Chassis back panel board"},
306         {PLDM_ENTITY_PROCESSING_BLADE, "Processing blade"},
307         {PLDM_ENTITY_CONNECTIVITY_SWITCH, "Connectivity switch"},
308         {PLDM_ENTITY_PROC_MEMORY_MODULE, "Processor/Memory Module"},
309         {PLDM_ENTITY_IO_MODULE, "I/O Module"},
310         {PLDM_ENTITY_PROC_IO_MODULE, "Processor I/O Module"},
311         {PLDM_ENTITY_COOLING_DEVICE, "Cooling device"},
312         {PLDM_ENTITY_COOLING_SUBSYSTEM, "Cooling subsystem"},
313         {PLDM_ENTITY_COOLING_UNIT, "Cooling Unit"},
314         {PLDM_ENTITY_FAN, "Fan"},
315         {PLDM_ENTITY_PELTIER_COOLING_DEVICE, "Peltier Cooling Device"},
316         {PLDM_ENTITY_LIQUID_COOLING_DEVICE, "Liquid Cooling Device"},
317         {PLDM_ENTITY_LIQUID_COOLING_SUBSYSTEM, "Liquid Colling Subsystem"},
318         {PLDM_ENTITY_OTHER_STORAGE_DEVICE, "Other Storage Device"},
319         {PLDM_ENTITY_FLOPPY_DRIVE, "Floppy Drive"},
320         {PLDM_ENTITY_FIXED_DISK_HARD_DRIVE, "Hard Drive"},
321         {PLDM_ENTITY_CD_DRIVE, "CD Drive"},
322         {PLDM_ENTITY_CD_DVD_DRIVE, "CD/DVD Drive"},
323         {PLDM_ENTITY_OTHER_SILICON_STORAGE_DEVICE,
324          "Other Silicon Storage Device"},
325         {PLDM_ENTITY_SOLID_STATE_SRIVE, "Solid State Drive"},
326         {PLDM_ENTITY_POWER_SUPPLY, "Power supply"},
327         {PLDM_ENTITY_BATTERY, "Battery"},
328         {PLDM_ENTITY_SUPER_CAPACITOR, "Super Capacitor"},
329         {PLDM_ENTITY_POWER_CONVERTER, "Power Converter"},
330         {PLDM_ENTITY_DC_DC_CONVERTER, "DC-DC Converter"},
331         {PLDM_ENTITY_AC_MAINS_POWER_SUPPLY, "AC mains power supply"},
332         {PLDM_ENTITY_DC_MAINS_POWER_SUPPLY, "DC mains power supply"},
333         {PLDM_ENTITY_PROC, "Processor"},
334         {PLDM_ENTITY_CHIPSET_COMPONENT, "Chipset Component"},
335         {PLDM_ENTITY_MGMT_CONTROLLER, "Management Controller"},
336         {PLDM_ENTITY_PERIPHERAL_CONTROLLER, "Peripheral Controller"},
337         {PLDM_ENTITY_SEEPROM, "SEEPROM"},
338         {PLDM_ENTITY_NVRAM_CHIP, "NVRAM Chip"},
339         {PLDM_ENTITY_FLASH_MEMORY_CHIP, "FLASH Memory chip"},
340         {PLDM_ENTITY_MEMORY_CHIP, "Memory Chip"},
341         {PLDM_ENTITY_MEMORY_CONTROLLER, "Memory Controller"},
342         {PLDM_ENTITY_NETWORK_CONTROLLER, "Network Controller"},
343         {PLDM_ENTITY_IO_CONTROLLER, "I/O Controller"},
344         {PLDM_ENTITY_SOUTH_BRIDGE, "South Bridge"},
345         {PLDM_ENTITY_REAL_TIME_CLOCK, "Real Time Clock (RTC)"},
346         {PLDM_ENTITY_FPGA_CPLD_DEVICE, "FPGA/CPLD Configurable Logic Device"},
347         {PLDM_ENTITY_OTHER_BUS, "Other Bus"},
348         {PLDM_ENTITY_SYS_BUS, "System Bus"},
349         {PLDM_ENTITY_I2C_BUS, "I2C Bus"},
350         {PLDM_ENTITY_SMBUS_BUS, "SMBus Bus"},
351         {PLDM_ENTITY_SPI_BUS, "SPI Bus"},
352         {PLDM_ENTITY_PCI_BUS, "PCI Bus"},
353         {PLDM_ENTITY_PCI_EXPRESS_BUS, "PCI Express Bus"},
354         {PLDM_ENTITY_PECI_BUS, "PECI Bus"},
355         {PLDM_ENTITY_LPC_BUS, "LPC Bus"},
356         {PLDM_ENTITY_USB_BUS, "USB Bus"},
357         {PLDM_ENTITY_FIREWIRE_BUS, "FireWire Bus"},
358         {PLDM_ENTITY_SCSI_BUS, "SCSI Bus"},
359         {PLDM_ENTITY_SATA_SAS_BUS, "SATA/SAS Bus"},
360         {PLDM_ENTITY_PROC_FRONT_SIDE_BUS, "Processor/Front-side Bus"},
361         {PLDM_ENTITY_INTER_PROC_BUS, "Inter-processor Bus"},
362         {PLDM_ENTITY_CONNECTOR, "Connector"},
363         {PLDM_ENTITY_SLOT, "Slot"},
364         {PLDM_ENTITY_CABLE, "Cable(electrical or optical)"},
365         {PLDM_ENTITY_INTERCONNECT, "Interconnect"},
366         {PLDM_ENTITY_PLUG, "Plug"},
367         {PLDM_ENTITY_SOCKET, "Socket"},
368     };
369 
370     const std::map<uint16_t, std::string> stateSet = {
371         {PLDM_STATE_SET_HEALTH_STATE, "Health State"},
372         {PLDM_STATE_SET_AVAILABILITY, "Availability"},
373         {PLDM_STATE_SET_PREDICTIVE_CONDITION, "Predictive Condition"},
374         {PLDM_STATE_SET_REDUNDANCY_STATUS, "Redundancy Status"},
375         {PLDM_STATE_SET_HEALTH_REDUNDANCY_TREND, "Health/Redundancy Trend"},
376         {PLDM_STATE_SET_GROUP_RESOURCE_LEVEL, "Group Resource Level"},
377         {PLDM_STATE_SET_REDUNDANCY_ENTITY_ROLE, "Redundancy Entity Role"},
378         {PLDM_STATE_SET_OPERATIONAL_STATUS, "Operational Status"},
379         {PLDM_STATE_SET_OPERATIONAL_STRESS_STATUS, "Operational Stress Status"},
380         {PLDM_STATE_SET_OPERATIONAL_FAULT_STATUS, "Operational Fault Status"},
381         {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS,
382          "Operational Running Status"},
383         {PLDM_STATE_SET_OPERATIONAL_CONNECTION_STATUS,
384          "Operational Connection Status"},
385         {PLDM_STATE_SET_PRESENCE, "Presence"},
386         {PLDM_STATE_SET_PERFORMANCE, "Performance"},
387         {PLDM_STATE_SET_CONFIGURATION_STATE, "Configuration State"},
388         {PLDM_STATE_SET_CHANGED_CONFIGURATION, "Changed Configuration"},
389         {PLDM_STATE_SET_IDENTIFY_STATE, "Identify State"},
390         {PLDM_STATE_SET_VERSION, "Version"},
391         {PLDM_STATE_SET_ALARM_STATE, "Alarm State"},
392         {PLDM_STATE_SET_DEVICE_INITIALIZATION, "Device Initialization"},
393         {PLDM_STATE_SET_THERMAL_TRIP, "Thermal Trip"},
394         {PLDM_STATE_SET_HEARTBEAT, "Heartbeat"},
395         {PLDM_STATE_SET_LINK_STATE, "Link State"},
396         {PLDM_STATE_SET_SMOKE_STATE, "Smoke State"},
397         {PLDM_STATE_SET_HUMIDITY_STATE, "Humidity State"},
398         {PLDM_STATE_SET_DOOR_STATE, "Door State"},
399         {PLDM_STATE_SET_SWITCH_STATE, "Switch State"},
400         {PLDM_STATE_SET_LOCK_STATE, "Lock State"},
401         {PLDM_STATE_SET_PHYSICAL_SECURITY, "Physical Security"},
402         {PLDM_STATE_SET_DOCK_AUTHORIZATION, "Dock Authorization"},
403         {PLDM_STATE_SET_HW_SECURITY, "Hardware Security"},
404         {PLDM_STATE_SET_PHYSICAL_COMM_CONNECTION,
405          "Physical Communication Connection"},
406         {PLDM_STATE_SET_COMM_LEASH_STATUS, "Communication Leash Status"},
407         {PLDM_STATE_SET_FOREIGN_NW_DETECTION_STATUS,
408          "Foreign Network Detection Status"},
409         {PLDM_STATE_SET_PASSWORD_PROTECTED_ACCESS_SECURITY,
410          "Password-Protected Access Security"},
411         {PLDM_STATE_SET_SECURITY_ACCESS_PRIVILEGE_LEVEL,
412          "Security Access –PrivilegeLevel"},
413         {PLDM_STATE_SET_SESSION_AUDIT, "PLDM Session Audit"},
414         {PLDM_STATE_SET_SW_TERMINATION_STATUS, "Software Termination Status"},
415         {PLDM_STATE_SET_STORAGE_MEDIA_ACTIVITY, "Storage Media Activity"},
416         {PLDM_STATE_SET_BOOT_RESTART_CAUSE, "Boot/Restart Cause"},
417         {PLDM_STATE_SET_BOOT_RESTART_REQUEST, "Boot/Restart Request"},
418         {PLDM_STATE_SET_ENTITY_BOOT_STATUS, "Entity Boot Status"},
419         {PLDM_STATE_SET_BOOT_ERROR_STATUS, "Boot ErrorStatus"},
420         {PLDM_STATE_SET_BOOT_PROGRESS, "Boot Progress"},
421         {PLDM_STATE_SET_SYS_FIRMWARE_HANG, "System Firmware Hang"},
422         {PLDM_STATE_SET_POST_ERRORS, "POST Errors"},
423         {PLDM_STATE_SET_LOG_FILL_STATUS, "Log Fill Status"},
424         {PLDM_STATE_SET_LOG_FILTER_STATUS, "Log Filter Status"},
425         {PLDM_STATE_SET_LOG_TIMESTAMP_CHANGE, "Log Timestamp Change"},
426         {PLDM_STATE_SET_INTERRUPT_REQUESTED, "Interrupt Requested"},
427         {PLDM_STATE_SET_INTERRUPT_RECEIVED, "Interrupt Received"},
428         {PLDM_STATE_SET_DIAGNOSTIC_INTERRUPT_REQUESTED,
429          "Diagnostic Interrupt Requested"},
430         {PLDM_STATE_SET_DIAGNOSTIC_INTERRUPT_RECEIVED,
431          "Diagnostic Interrupt Received"},
432         {PLDM_STATE_SET_IO_CHANNEL_CHECK_NMI_REQUESTED,
433          "I/O Channel Check NMI Requested"},
434         {PLDM_STATE_SET_IO_CHANNEL_CHECK_NMI_RECEIVED,
435          "I/O Channel Check NMI Received"},
436         {PLDM_STATE_SET_FATAL_NMI_REQUESTED, "Fatal NMI Requested"},
437         {PLDM_STATE_SET_FATAL_NMI_RECEIVED, "Fatal NMI Received"},
438         {PLDM_STATE_SET_SOFTWARE_NMI_REQUESTED, "Software NMI Requested"},
439         {PLDM_STATE_SET_SOFTWARE_NMI_RECEIVED, "Software NMI Received"},
440         {PLDM_STATE_SET_SMI_REQUESTED, "SMI Requested"},
441         {PLDM_STATE_SET_SMI_RECEIVED, "SMI Received"},
442         {PLDM_STATE_SET_PCI_PERR_REQUESTED, "PCI PERR Requested"},
443         {PLDM_STATE_SET_PCI_PERR_RECEIVED, "PCI PERR Received"},
444         {PLDM_STATE_SET_PCI_SERR_REQUESTED, "PCI SERR Requested "},
445         {PLDM_STATE_SET_PCI_SERR_RECEIVED, "PCI SERR Received"},
446         {PLDM_STATE_SET_BUS_ERROR_STATUS, "Bus Error Status"},
447         {PLDM_STATE_SET_WATCHDOG_STATUS, "Watchdog Status"},
448         {PLDM_STATE_SET_POWER_SUPPLY_STATE, "Power Supply State"},
449         {PLDM_STATE_SET_DEVICE_POWER_STATE, "Device Power State"},
450         {PLDM_STATE_SET_ACPI_POWER_STATE, "ACPI Power State"},
451         {PLDM_STATE_SET_BACKUP_POWER_SOURCE, "Backup Power Source"},
452         {PLDM_STATE_SET_SYSTEM_POWER_STATE, "System Power State "},
453         {PLDM_STATE_SET_BATTERY_ACTIVITY, "Battery Activity"},
454         {PLDM_STATE_SET_BATTERY_STATE, "Battery State"},
455         {PLDM_STATE_SET_PROC_POWER_STATE, "Processor Power State"},
456         {PLDM_STATE_SET_POWER_PERFORMANCE_STATE, "Power-Performance State"},
457         {PLDM_STATE_SET_PROC_ERROR_STATUS, "Processor Error Status"},
458         {PLDM_STATE_SET_BIST_FAILURE_STATUS, "BIST FailureStatus"},
459         {PLDM_STATE_SET_IBIST_FAILURE_STATUS, "IBIST FailureStatus"},
460         {PLDM_STATE_SET_PROC_HANG_IN_POST, "Processor Hang in POST"},
461         {PLDM_STATE_SET_PROC_STARTUP_FAILURE, "Processor Startup Failure"},
462         {PLDM_STATE_SET_UNCORRECTABLE_CPU_ERROR, "Uncorrectable CPU Error"},
463         {PLDM_STATE_SET_MACHINE_CHECK_ERROR, "Machine Check Error"},
464         {PLDM_STATE_SET_CORRECTED_MACHINE_CHECK, "Corrected Machine Check"},
465         {PLDM_STATE_SET_CACHE_STATUS, "Cache Status"},
466         {PLDM_STATE_SET_MEMORY_ERROR_STATUS, "Memory Error Status"},
467         {PLDM_STATE_SET_REDUNDANT_MEMORY_ACTIVITY_STATUS,
468          "Redundant Memory Activity Status"},
469         {PLDM_STATE_SET_ERROR_DETECTION_STATUS, "Error Detection Status"},
470         {PLDM_STATE_SET_STUCK_BIT_STATUS, "Stuck Bit Status"},
471         {PLDM_STATE_SET_SCRUB_STATUS, "Scrub Status"},
472         {PLDM_STATE_SET_SLOT_OCCUPANCY, "Slot Occupancy"},
473         {PLDM_STATE_SET_SLOT_STATE, "Slot State"},
474     };
475 
476     const std::array<std::string_view, 4> sensorInit = {
477         "noInit", "useInitPDR", "enableSensor", "disableSensor"};
478 
479     const std::array<std::string_view, 4> effecterInit = {
480         "noInit", "useInitPDR", "enableEffecter", "disableEffecter"};
481 
482     const std::map<uint8_t, std::string> pdrType = {
483         {PLDM_TERMINUS_LOCATOR_PDR, "Terminus Locator PDR"},
484         {PLDM_NUMERIC_SENSOR_PDR, "Numeric Sensor PDR"},
485         {PLDM_NUMERIC_SENSOR_INITIALIZATION_PDR,
486          "Numeric Sensor Initialization PDR"},
487         {PLDM_STATE_SENSOR_PDR, "State Sensor PDR"},
488         {PLDM_STATE_SENSOR_INITIALIZATION_PDR,
489          "State Sensor Initialization PDR"},
490         {PLDM_SENSOR_AUXILIARY_NAMES_PDR, "Sensor Auxiliary Names PDR"},
491         {PLDM_OEM_UNIT_PDR, "OEM Unit PDR"},
492         {PLDM_OEM_STATE_SET_PDR, "OEM State Set PDR"},
493         {PLDM_NUMERIC_EFFECTER_PDR, "Numeric Effecter PDR"},
494         {PLDM_NUMERIC_EFFECTER_INITIALIZATION_PDR,
495          "Numeric Effecter Initialization PDR"},
496         {PLDM_COMPACT_NUMERIC_SENSOR_PDR, "Compact Numeric Sensor PDR"},
497         {PLDM_STATE_EFFECTER_PDR, "State Effecter PDR"},
498         {PLDM_STATE_EFFECTER_INITIALIZATION_PDR,
499          "State Effecter Initialization PDR"},
500         {PLDM_EFFECTER_AUXILIARY_NAMES_PDR, "Effecter Auxiliary Names PDR"},
501         {PLDM_EFFECTER_OEM_SEMANTIC_PDR, "Effecter OEM Semantic PDR"},
502         {PLDM_PDR_ENTITY_ASSOCIATION, "Entity Association PDR"},
503         {PLDM_ENTITY_AUXILIARY_NAMES_PDR, "Entity Auxiliary Names PDR"},
504         {PLDM_OEM_ENTITY_ID_PDR, "OEM Entity ID PDR"},
505         {PLDM_INTERRUPT_ASSOCIATION_PDR, "Interrupt Association PDR"},
506         {PLDM_EVENT_LOG_PDR, "PLDM Event Log PDR"},
507         {PLDM_PDR_FRU_RECORD_SET, "FRU Record Set PDR"},
508         {PLDM_OEM_DEVICE_PDR, "OEM Device PDR"},
509         {PLDM_OEM_PDR, "OEM PDR"},
510     };
511 
512     static inline const std::map<uint8_t, std::string> setThermalTrip{
513         {PLDM_STATE_SET_THERMAL_TRIP_STATUS_NORMAL, "Normal"},
514         {PLDM_STATE_SET_THERMAL_TRIP_STATUS_THERMAL_TRIP, "Thermal Trip"}};
515 
516     static inline const std::map<uint8_t, std::string> setIdentifyState{
517         {PLDM_STATE_SET_IDENTIFY_STATE_UNASSERTED, "Identify State Unasserted"},
518         {PLDM_STATE_SET_IDENTIFY_STATE_ASSERTED, "Identify State Asserted"}};
519 
520     static inline const std::map<uint8_t, std::string> setBootProgressState{
521         {PLDM_STATE_SET_BOOT_PROG_STATE_NOT_ACTIVE, "Boot Not Active"},
522         {PLDM_STATE_SET_BOOT_PROG_STATE_COMPLETED, "Boot Completed"},
523         {PLDM_STATE_SET_BOOT_PROG_STATE_MEM_INITIALIZATION,
524          "Memory Initialization"},
525         {PLDM_STATE_SET_BOOT_PROG_STATE_SEC_PROC_INITIALIZATION,
526          "Secondary Processor(s) Initialization"},
527         {PLDM_STATE_SET_BOOT_PROG_STATE_PCI_RESORUCE_CONFIG,
528          "PCI Resource Configuration"},
529         {PLDM_STATE_SET_BOOT_PROG_STATE_STARTING_OP_SYS,
530          "Starting Operating System"},
531         {PLDM_STATE_SET_BOOT_PROG_STATE_BASE_BOARD_INITIALIZATION,
532          "Baseboard Initialization"},
533         {PLDM_STATE_SET_BOOT_PROG_STATE_PRIMARY_PROC_INITIALIZATION,
534          "Primary Processor Initialization"},
535         {PLDM_STATE_SET_BOOT_PROG_STATE_OSSTART, "OSStart"}};
536 
537     static inline const std::map<uint8_t, std::string> setOpFaultStatus{
538         {PLDM_STATE_SET_OPERATIONAL_FAULT_STATUS_NORMAL, "Normal"},
539         {PLDM_STATE_SET_OPERATIONAL_FAULT_STATUS_ERROR, "Error"},
540         {PLDM_STATE_SET_OPERATIONAL_FAULT_STATUS_NON_RECOVERABLE_ERROR,
541          "Non Recoverable Error"}};
542 
543     static inline const std::map<uint8_t, std::string> setSysPowerState{
544         {PLDM_STATE_SET_SYS_POWER_STATE_OFF_SOFT_GRACEFUL,
545          "Off-Soft Graceful"}};
546 
547     static inline const std::map<uint8_t, std::string> setSWTerminationStatus{
548         {PLDM_SW_TERM_GRACEFUL_RESTART_REQUESTED,
549          "Graceful Restart Requested"}};
550 
551     static inline const std::map<uint8_t, std::string> setAvailability{
552         {PLDM_STATE_SET_AVAILABILITY_REBOOTING, "Rebooting"}};
553 
554     static inline const std::map<uint8_t, std::string> setHealthState{
555         {PLDM_STATE_SET_HEALTH_STATE_NORMAL, "Normal"},
556         {PLDM_STATE_SET_HEALTH_STATE_NON_CRITICAL, "Non-Critical"},
557         {PLDM_STATE_SET_HEALTH_STATE_CRITICAL, "Critical"},
558         {PLDM_STATE_SET_HEALTH_STATE_FATAL, "Fatal"},
559         {PLDM_STATE_SET_HEALTH_STATE_UPPER_NON_CRITICAL, "Upper Non-Critical"},
560         {PLDM_STATE_SET_HEALTH_STATE_LOWER_NON_CRITICAL, "Lower Non-Critical"},
561         {PLDM_STATE_SET_HEALTH_STATE_UPPER_CRITICAL, "Upper Critical"},
562         {PLDM_STATE_SET_HEALTH_STATE_LOWER_CRITICAL, "Lower Critical"},
563         {PLDM_STATE_SET_HEALTH_STATE_UPPER_FATAL, "Upper Fatal"},
564         {PLDM_STATE_SET_HEALTH_STATE_LOWER_FATAL, "Lower Fatal"}};
565 
566     static inline const std::map<uint8_t, std::string>
567         setOperationalRunningState{
568             {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_STARTING, "Starting"},
569             {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_STOPPING, "Stopping"},
570             {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_STOPPED, "Stopped"},
571             {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_IN_SERVICE,
572              "In Service"},
573             {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_ABORTED, "Aborted"},
574             {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_DORMANT, "Dormant"}};
575 
576     static inline const std::map<uint8_t, std::string> setPowerDeviceState{
577         {PLDM_STATE_SET_ACPI_DEVICE_POWER_STATE_UNKNOWN, "Unknown"},
578         {PLDM_STATE_SET_ACPI_DEVICE_POWER_STATE_FULLY_ON, "Fully-On"},
579         {PLDM_STATE_SET_ACPI_DEVICE_POWER_STATE_INTERMEDIATE_1,
580          "Intermediate State-1"},
581         {PLDM_STATE_SET_ACPI_DEVICE_POWER_STATE_INTERMEDIATE_2,
582          "Intermediate State-2"},
583         {PLDM_STATE_SET_ACPI_DEVICE_POWER_STATE_OFF, "Off"}};
584 
585     static inline const std::map<uint16_t, const std::map<uint8_t, std::string>>
586         populatePStateMaps{
587             {PLDM_STATE_SET_THERMAL_TRIP, setThermalTrip},
588             {PLDM_STATE_SET_IDENTIFY_STATE, setIdentifyState},
589             {PLDM_STATE_SET_BOOT_PROGRESS, setBootProgressState},
590             {PLDM_STATE_SET_OPERATIONAL_FAULT_STATUS, setOpFaultStatus},
591             {PLDM_STATE_SET_SYSTEM_POWER_STATE, setSysPowerState},
592             {PLDM_STATE_SET_SW_TERMINATION_STATUS, setSWTerminationStatus},
593             {PLDM_STATE_SET_AVAILABILITY, setAvailability},
594             {PLDM_STATE_SET_HEALTH_STATE, setHealthState},
595             {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS,
596              setOperationalRunningState},
597             {PLDM_STATE_SET_DEVICE_POWER_STATE, setPowerDeviceState},
598         };
599 
600     const std::map<std::string, uint8_t> strToPdrType = {
601         {"terminuslocator", PLDM_TERMINUS_LOCATOR_PDR},
602         {"statesensor", PLDM_STATE_SENSOR_PDR},
603         {"sensorauxname", PLDM_SENSOR_AUXILIARY_NAMES_PDR},
604         {"numericeffecter", PLDM_NUMERIC_EFFECTER_PDR},
605         {"efffecterauxname", PLDM_EFFECTER_AUXILIARY_NAMES_PDR},
606         {"numericsensor", PLDM_NUMERIC_SENSOR_PDR},
607         {"compactnumericsensor", PLDM_COMPACT_NUMERIC_SENSOR_PDR},
608         {"stateeffecter", PLDM_STATE_EFFECTER_PDR},
609         {"entityassociation", PLDM_PDR_ENTITY_ASSOCIATION},
610         {"frurecord", PLDM_PDR_FRU_RECORD_SET},
611         // Add other types
612     };
613 
614     bool isLogicalBitSet(const uint16_t entity_type)
615     {
616         return entity_type & 0x8000;
617     }
618 
619     uint16_t getEntityTypeForLogicalEntity(const uint16_t logical_entity_type)
620     {
621         return logical_entity_type & 0x7FFF;
622     }
623 
624     std::string getEntityName(pldm::pdr::EntityType type)
625     {
626         uint16_t entityNumber = type;
627         std::string entityName = "[Physical] ";
628 
629         if (isLogicalBitSet(type))
630         {
631             entityName = "[Logical] ";
632             entityNumber = getEntityTypeForLogicalEntity(type);
633         }
634 
635         try
636         {
637             return entityName + entityType.at(entityNumber);
638         }
639         catch (const std::out_of_range& e)
640         {
641             auto OemString =
642                 std::to_string(static_cast<unsigned>(entityNumber));
643             if (type >= PLDM_OEM_ENTITY_TYPE_START &&
644                 type <= PLDM_OEM_ENTITY_TYPE_END)
645             {
646 #ifdef OEM_IBM
647                 if (OemIBMEntityType.contains(entityNumber))
648                 {
649                     return entityName + OemIBMEntityType.at(entityNumber) +
650                            "(OEM)";
651                 }
652 #endif
653                 return entityName + OemString + "(OEM)";
654             }
655             return OemString;
656         }
657     }
658 
659     std::string getStateSetName(uint16_t id)
660     {
661         auto typeString = std::to_string(id);
662         try
663         {
664             return stateSet.at(id) + "(" + typeString + ")";
665         }
666         catch (const std::out_of_range& e)
667         {
668             return typeString;
669         }
670     }
671 
672     std::vector<std::string>
673         getStateSetPossibleStateNames(uint16_t stateId,
674                                       const std::vector<uint8_t>& value)
675     {
676         std::vector<std::string> data{};
677 
678         for (const auto& s : value)
679         {
680             std::map<uint8_t, std::string> stateNameMaps;
681             auto pstr = std::to_string(s);
682 
683 #ifdef OEM_IBM
684             if (stateId >= PLDM_OEM_STATE_SET_ID_START &&
685                 stateId < PLDM_OEM_STATE_SET_ID_END)
686             {
687                 if (populateOemIBMStateMaps.contains(stateId))
688                 {
689                     const std::map<uint8_t, std::string> stateNames =
690                         populateOemIBMStateMaps.at(stateId);
691                     stateNameMaps.insert(stateNames.begin(), stateNames.end());
692                 }
693             }
694 #endif
695             if (populatePStateMaps.contains(stateId))
696             {
697                 const std::map<uint8_t, std::string> stateNames =
698                     populatePStateMaps.at(stateId);
699                 stateNameMaps.insert(stateNames.begin(), stateNames.end());
700             }
701             if (stateNameMaps.contains(s))
702             {
703                 data.push_back(stateNameMaps.at(s) + "(" + pstr + ")");
704             }
705             else
706             {
707                 data.push_back(pstr);
708             }
709         }
710         return data;
711     }
712 
713     std::string getPDRType(uint8_t type)
714     {
715         auto typeString = std::to_string(type);
716         try
717         {
718             return pdrType.at(type);
719         }
720         catch (const std::out_of_range& e)
721         {
722             return typeString;
723         }
724     }
725 
726     void printCommonPDRHeader(const pldm_pdr_hdr* hdr, ordered_json& output)
727     {
728         output["recordHandle"] = hdr->record_handle;
729         output["PDRHeaderVersion"] = unsigned(hdr->version);
730         output["PDRType"] = getPDRType(hdr->type);
731         output["recordChangeNumber"] = hdr->record_change_num;
732         output["dataLength"] = hdr->length;
733     }
734 
735     std::vector<uint8_t> printPossibleStates(uint8_t possibleStatesSize,
736                                              const bitfield8_t* states)
737     {
738         uint8_t possibleStatesPos{};
739         std::vector<uint8_t> data{};
740         auto printStates = [&possibleStatesPos, &data](const bitfield8_t& val) {
741             std::stringstream pstates;
742             for (int i = 0; i < CHAR_BIT; i++)
743             {
744                 if (val.byte & (1 << i))
745                 {
746                     pstates << (possibleStatesPos * CHAR_BIT + i);
747                     data.push_back(
748                         static_cast<uint8_t>(std::stoi(pstates.str())));
749                     pstates.str("");
750                 }
751             }
752             possibleStatesPos++;
753         };
754         std::for_each(states, states + possibleStatesSize, printStates);
755         return data;
756     }
757 
758     void printStateSensorPDR(const uint8_t* data, ordered_json& output)
759     {
760         auto pdr = reinterpret_cast<const pldm_state_sensor_pdr*>(data);
761         output["PLDMTerminusHandle"] = pdr->terminus_handle;
762         output["sensorID"] = pdr->sensor_id;
763         output["entityType"] = getEntityName(pdr->entity_type);
764         output["entityInstanceNumber"] = pdr->entity_instance;
765         output["containerID"] = pdr->container_id;
766         output["sensorInit"] = sensorInit[pdr->sensor_init];
767         output["sensorAuxiliaryNamesPDR"] =
768             (pdr->sensor_auxiliary_names_pdr ? true : false);
769         output["compositeSensorCount"] = unsigned(pdr->composite_sensor_count);
770 
771         auto statesPtr = pdr->possible_states;
772         auto compCount = pdr->composite_sensor_count;
773 
774         while (compCount--)
775         {
776             auto state = reinterpret_cast<const state_sensor_possible_states*>(
777                 statesPtr);
778             output.emplace(("stateSetID[" + std::to_string(compCount) + "]"),
779                            getStateSetName(state->state_set_id));
780             output.emplace(
781                 ("possibleStatesSize[" + std::to_string(compCount) + "]"),
782                 state->possible_states_size);
783             output.emplace(
784                 ("possibleStates[" + std::to_string(compCount) + "]"),
785                 getStateSetPossibleStateNames(
786                     state->state_set_id,
787                     printPossibleStates(state->possible_states_size,
788                                         state->states)));
789 
790             if (compCount)
791             {
792                 statesPtr += sizeof(state_sensor_possible_states) +
793                              state->possible_states_size - 1;
794             }
795         }
796     }
797 
798     void printPDRFruRecordSet(uint8_t* data, ordered_json& output)
799     {
800         if (data == NULL)
801         {
802             return;
803         }
804 
805         data += sizeof(pldm_pdr_hdr);
806         pldm_pdr_fru_record_set* pdr =
807             reinterpret_cast<pldm_pdr_fru_record_set*>(data);
808         if (!pdr)
809         {
810             std::cerr << "Failed to get the FRU record set PDR" << std::endl;
811             return;
812         }
813 
814         output["PLDMTerminusHandle"] = unsigned(pdr->terminus_handle);
815         output["FRURecordSetIdentifier"] = unsigned(pdr->fru_rsi);
816         output["entityType"] = getEntityName(pdr->entity_type);
817         output["entityInstanceNumber"] = unsigned(pdr->entity_instance);
818         output["containerID"] = unsigned(pdr->container_id);
819     }
820 
821     void printPDREntityAssociation(uint8_t* data, ordered_json& output)
822     {
823         const std::map<uint8_t, const char*> assocationType = {
824             {PLDM_ENTITY_ASSOCIAION_PHYSICAL, "Physical"},
825             {PLDM_ENTITY_ASSOCIAION_LOGICAL, "Logical"},
826         };
827 
828         if (data == NULL)
829         {
830             return;
831         }
832 
833         data += sizeof(pldm_pdr_hdr);
834         pldm_pdr_entity_association* pdr =
835             reinterpret_cast<pldm_pdr_entity_association*>(data);
836         if (!pdr)
837         {
838             std::cerr << "Failed to get the PDR eneity association"
839                       << std::endl;
840             return;
841         }
842 
843         output["containerID"] = int(pdr->container_id);
844         if (assocationType.contains(pdr->association_type))
845         {
846             output["associationType"] =
847                 assocationType.at(pdr->association_type);
848         }
849         else
850         {
851             std::cout << "Get associationType failed.\n";
852         }
853         output["containerEntityType"] =
854             getEntityName(pdr->container.entity_type);
855         output["containerEntityInstanceNumber"] =
856             int(pdr->container.entity_instance_num);
857         output["containerEntityContainerID"] =
858             int(pdr->container.entity_container_id);
859         output["containedEntityCount"] =
860             static_cast<unsigned>(pdr->num_children);
861 
862         auto child = reinterpret_cast<pldm_entity*>(&pdr->children[0]);
863         for (int i = 0; i < pdr->num_children; ++i)
864         {
865             output.emplace("containedEntityType[" + std::to_string(i + 1) + "]",
866                            getEntityName(child->entity_type));
867             output.emplace("containedEntityInstanceNumber[" +
868                                std::to_string(i + 1) + "]",
869                            unsigned(child->entity_instance_num));
870             output.emplace("containedEntityContainerID[" +
871                                std::to_string(i + 1) + "]",
872                            unsigned(child->entity_container_id));
873 
874             ++child;
875         }
876     }
877 
878     /** @brief Format the Sensor/Effecter Aux Name PDR types to json output
879      *
880      *  @param[in] data - reference to the Sensor/Effecter Aux Name PDR
881      *  @param[out] output - PDRs data fields in Json format
882      */
883     void printAuxNamePDR(uint8_t* data, ordered_json& output)
884     {
885         constexpr uint8_t nullTerminator = 0;
886         struct pldm_effecter_aux_name_pdr* auxNamePdr =
887             (struct pldm_effecter_aux_name_pdr*)data;
888 
889         if (!auxNamePdr)
890         {
891             std::cerr << "Failed to get Aux Name PDR" << std::endl;
892             return;
893         }
894 
895         std::string sPrefix = "effecter";
896         if (auxNamePdr->hdr.type == PLDM_SENSOR_AUXILIARY_NAMES_PDR)
897         {
898             sPrefix = "sensor";
899         }
900         output["terminusHandle"] = int(auxNamePdr->terminus_handle);
901         output[sPrefix + "Id"] = int(auxNamePdr->effecter_id);
902         output[sPrefix + "Count"] = int(auxNamePdr->effecter_count);
903 
904         const uint8_t* ptr = auxNamePdr->effecter_names;
905         for (auto i : std::views::iota(0, (int)auxNamePdr->effecter_count))
906         {
907             const uint8_t nameStringCount = static_cast<uint8_t>(*ptr);
908             ptr += sizeof(uint8_t);
909             for (auto j : std::views::iota(0, (int)nameStringCount))
910             {
911                 std::string nameLanguageTagKey = sPrefix + std::to_string(j) +
912                                                  "_nameLanguageTag" +
913                                                  std::to_string(i);
914                 std::string entityAuxNameKey = sPrefix + std::to_string(j) +
915                                                "_entityAuxName" +
916                                                std::to_string(i);
917                 std::string nameLanguageTag(reinterpret_cast<const char*>(ptr),
918                                             0, PLDM_STR_UTF_8_MAX_LEN);
919                 ptr += nameLanguageTag.size() + sizeof(nullTerminator);
920                 std::u16string u16NameString(
921                     reinterpret_cast<const char16_t*>(ptr), 0,
922                     PLDM_STR_UTF_16_MAX_LEN);
923                 ptr += (u16NameString.size() + sizeof(nullTerminator)) *
924                        sizeof(uint16_t);
925                 std::transform(u16NameString.cbegin(), u16NameString.cend(),
926                                u16NameString.begin(),
927                                [](uint16_t utf16) { return be16toh(utf16); });
928                 std::string nameString =
929                     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>,
930                                          char16_t>{}
931                         .to_bytes(u16NameString);
932                 output[nameLanguageTagKey] = nameLanguageTag;
933                 output[entityAuxNameKey] = nameString;
934             }
935         }
936     }
937 
938     void printNumericEffecterPDR(uint8_t* data, ordered_json& output)
939     {
940         struct pldm_numeric_effecter_value_pdr* pdr =
941             (struct pldm_numeric_effecter_value_pdr*)data;
942         if (!pdr)
943         {
944             std::cerr << "Failed to get numeric effecter PDR" << std::endl;
945             return;
946         }
947 
948         output["PLDMTerminusHandle"] = int(pdr->terminus_handle);
949         output["effecterID"] = int(pdr->effecter_id);
950         output["entityType"] = int(pdr->entity_type);
951         output["entityInstanceNumber"] = int(pdr->entity_instance);
952         output["containerID"] = int(pdr->container_id);
953         output["effecterSemanticID"] = int(pdr->effecter_semantic_id);
954         output["effecterInit"] = unsigned(pdr->effecter_init);
955         output["effecterAuxiliaryNames"] =
956             (unsigned(pdr->effecter_auxiliary_names) ? true : false);
957         output["baseUnit"] = unsigned(pdr->base_unit);
958         output["unitModifier"] = unsigned(pdr->unit_modifier);
959         output["rateUnit"] = unsigned(pdr->rate_unit);
960         output["baseOEMUnitHandle"] = unsigned(pdr->base_oem_unit_handle);
961         output["auxUnit"] = unsigned(pdr->aux_unit);
962         output["auxUnitModifier"] = unsigned(pdr->aux_unit_modifier);
963         output["auxrateUnit"] = unsigned(pdr->aux_rate_unit);
964         output["auxOEMUnitHandle"] = unsigned(pdr->aux_oem_unit_handle);
965         output["isLinear"] = (unsigned(pdr->is_linear) ? true : false);
966         output["effecterDataSize"] = unsigned(pdr->effecter_data_size);
967         output["resolution"] = unsigned(pdr->resolution);
968         output["offset"] = unsigned(pdr->offset);
969         output["accuracy"] = unsigned(pdr->accuracy);
970         output["plusTolerance"] = unsigned(pdr->plus_tolerance);
971         output["minusTolerance"] = unsigned(pdr->minus_tolerance);
972         output["stateTransitionInterval"] =
973             unsigned(pdr->state_transition_interval);
974         output["TransitionInterval"] = unsigned(pdr->transition_interval);
975 
976         switch (pdr->effecter_data_size)
977         {
978             case PLDM_EFFECTER_DATA_SIZE_UINT8:
979                 output["maxSettable"] = unsigned(pdr->max_settable.value_u8);
980                 output["minSettable"] = unsigned(pdr->min_settable.value_u8);
981                 break;
982             case PLDM_EFFECTER_DATA_SIZE_SINT8:
983                 output["maxSettable"] = unsigned(pdr->max_settable.value_s8);
984                 output["minSettable"] = unsigned(pdr->min_settable.value_s8);
985                 break;
986             case PLDM_EFFECTER_DATA_SIZE_UINT16:
987                 output["maxSettable"] = unsigned(pdr->max_settable.value_u16);
988                 output["minSettable"] = unsigned(pdr->min_settable.value_u16);
989                 break;
990             case PLDM_EFFECTER_DATA_SIZE_SINT16:
991                 output["maxSettable"] = unsigned(pdr->max_settable.value_s16);
992                 output["minSettable"] = unsigned(pdr->min_settable.value_s16);
993                 break;
994             case PLDM_EFFECTER_DATA_SIZE_UINT32:
995                 output["maxSettable"] = unsigned(pdr->max_settable.value_u32);
996                 output["minSettable"] = unsigned(pdr->min_settable.value_u32);
997                 break;
998             case PLDM_EFFECTER_DATA_SIZE_SINT32:
999                 output["maxSettable"] = unsigned(pdr->max_settable.value_s32);
1000                 output["minSettable"] = unsigned(pdr->min_settable.value_s32);
1001                 break;
1002             default:
1003                 break;
1004         }
1005 
1006         output["rangeFieldFormat"] = unsigned(pdr->range_field_format);
1007         output["rangeFieldSupport"] = unsigned(pdr->range_field_support.byte);
1008 
1009         switch (pdr->range_field_format)
1010         {
1011             case PLDM_RANGE_FIELD_FORMAT_UINT8:
1012                 output["nominalValue"] = unsigned(pdr->nominal_value.value_u8);
1013                 output["normalMax"] = unsigned(pdr->normal_max.value_u8);
1014                 output["normalMin"] = unsigned(pdr->normal_min.value_u8);
1015                 output["ratedMax"] = unsigned(pdr->rated_max.value_u8);
1016                 output["ratedMin"] = unsigned(pdr->rated_min.value_u8);
1017                 break;
1018             case PLDM_RANGE_FIELD_FORMAT_SINT8:
1019                 output["nominalValue"] = unsigned(pdr->nominal_value.value_s8);
1020                 output["normalMax"] = unsigned(pdr->normal_max.value_s8);
1021                 output["normalMin"] = unsigned(pdr->normal_min.value_s8);
1022                 output["ratedMax"] = unsigned(pdr->rated_max.value_s8);
1023                 output["ratedMin"] = unsigned(pdr->rated_min.value_s8);
1024                 break;
1025             case PLDM_RANGE_FIELD_FORMAT_UINT16:
1026                 output["nominalValue"] = unsigned(pdr->nominal_value.value_u16);
1027                 output["normalMax"] = unsigned(pdr->normal_max.value_u16);
1028                 output["normalMin"] = unsigned(pdr->normal_min.value_u16);
1029                 output["ratedMax"] = unsigned(pdr->rated_max.value_u16);
1030                 output["ratedMin"] = unsigned(pdr->rated_min.value_u16);
1031                 break;
1032             case PLDM_RANGE_FIELD_FORMAT_SINT16:
1033                 output["nominalValue"] = unsigned(pdr->nominal_value.value_s16);
1034                 output["normalMax"] = unsigned(pdr->normal_max.value_s16);
1035                 output["normalMin"] = unsigned(pdr->normal_min.value_s16);
1036                 output["ratedMax"] = unsigned(pdr->rated_max.value_s16);
1037                 output["ratedMin"] = unsigned(pdr->rated_min.value_s16);
1038                 break;
1039             case PLDM_RANGE_FIELD_FORMAT_UINT32:
1040                 output["nominalValue"] = unsigned(pdr->nominal_value.value_u32);
1041                 output["normalMax"] = unsigned(pdr->normal_max.value_u32);
1042                 output["normalMin"] = unsigned(pdr->normal_min.value_u32);
1043                 output["ratedMax"] = unsigned(pdr->rated_max.value_u32);
1044                 output["ratedMin"] = unsigned(pdr->rated_min.value_u32);
1045                 break;
1046             case PLDM_RANGE_FIELD_FORMAT_SINT32:
1047                 output["nominalValue"] = unsigned(pdr->nominal_value.value_s32);
1048                 output["normalMax"] = unsigned(pdr->normal_max.value_s32);
1049                 output["normalMin"] = unsigned(pdr->normal_min.value_s32);
1050                 output["ratedMax"] = unsigned(pdr->rated_max.value_s32);
1051                 output["ratedMin"] = unsigned(pdr->rated_min.value_s32);
1052                 break;
1053             case PLDM_RANGE_FIELD_FORMAT_REAL32:
1054                 output["nominalValue"] = unsigned(pdr->nominal_value.value_f32);
1055                 output["normalMax"] = unsigned(pdr->normal_max.value_f32);
1056                 output["normalMin"] = unsigned(pdr->normal_min.value_f32);
1057                 output["ratedMax"] = unsigned(pdr->rated_max.value_f32);
1058                 output["ratedMin"] = unsigned(pdr->rated_min.value_f32);
1059                 break;
1060             default:
1061                 break;
1062         }
1063     }
1064 
1065     void printStateEffecterPDR(const uint8_t* data, ordered_json& output)
1066     {
1067         auto pdr = reinterpret_cast<const pldm_state_effecter_pdr*>(data);
1068 
1069         output["PLDMTerminusHandle"] = pdr->terminus_handle;
1070         output["effecterID"] = pdr->effecter_id;
1071         output["entityType"] = getEntityName(pdr->entity_type);
1072         output["entityInstanceNumber"] = pdr->entity_instance;
1073         output["containerID"] = pdr->container_id;
1074         output["effecterSemanticID"] = pdr->effecter_semantic_id;
1075         output["effecterInit"] = effecterInit[pdr->effecter_init];
1076         output["effecterDescriptionPDR"] = (pdr->has_description_pdr ? true
1077                                                                      : false);
1078         output["compositeEffecterCount"] =
1079             unsigned(pdr->composite_effecter_count);
1080 
1081         auto statesPtr = pdr->possible_states;
1082         auto compEffCount = pdr->composite_effecter_count;
1083 
1084         while (compEffCount--)
1085         {
1086             auto state =
1087                 reinterpret_cast<const state_effecter_possible_states*>(
1088                     statesPtr);
1089             output.emplace(("stateSetID[" + std::to_string(compEffCount) + "]"),
1090                            getStateSetName(state->state_set_id));
1091             output.emplace(
1092                 ("possibleStatesSize[" + std::to_string(compEffCount) + "]"),
1093                 state->possible_states_size);
1094             output.emplace(
1095                 ("possibleStates[" + std::to_string(compEffCount) + "]"),
1096                 getStateSetPossibleStateNames(
1097                     state->state_set_id,
1098                     printPossibleStates(state->possible_states_size,
1099                                         state->states)));
1100 
1101             if (compEffCount)
1102             {
1103                 statesPtr += sizeof(state_effecter_possible_states) +
1104                              state->possible_states_size - 1;
1105             }
1106         }
1107     }
1108 
1109     bool checkTerminusHandle(const uint8_t* data,
1110                              std::optional<uint16_t> terminusHandle)
1111     {
1112         struct pldm_pdr_hdr* pdr = (struct pldm_pdr_hdr*)data;
1113 
1114         if (pdr->type == PLDM_TERMINUS_LOCATOR_PDR)
1115         {
1116             auto tlpdr =
1117                 reinterpret_cast<const pldm_terminus_locator_pdr*>(data);
1118 
1119             if (tlpdr->terminus_handle != terminusHandle)
1120             {
1121                 return true;
1122             }
1123         }
1124         else if (pdr->type == PLDM_STATE_SENSOR_PDR)
1125         {
1126             auto sensor = reinterpret_cast<const pldm_state_sensor_pdr*>(data);
1127 
1128             if (sensor->terminus_handle != terminusHandle)
1129             {
1130                 return true;
1131             }
1132         }
1133         else if (pdr->type == PLDM_NUMERIC_EFFECTER_PDR)
1134         {
1135             auto numericEffecter =
1136                 reinterpret_cast<const pldm_numeric_effecter_value_pdr*>(data);
1137 
1138             if (numericEffecter->terminus_handle != terminusHandle)
1139             {
1140                 return true;
1141             }
1142         }
1143 
1144         else if (pdr->type == PLDM_STATE_EFFECTER_PDR)
1145         {
1146             auto stateEffecter =
1147                 reinterpret_cast<const pldm_state_effecter_pdr*>(data);
1148             if (stateEffecter->terminus_handle != terminusHandle)
1149             {
1150                 return true;
1151             }
1152         }
1153         else if (pdr->type == PLDM_PDR_FRU_RECORD_SET)
1154         {
1155             data += sizeof(pldm_pdr_hdr);
1156             auto fru = reinterpret_cast<const pldm_pdr_fru_record_set*>(data);
1157 
1158             if (fru->terminus_handle != terminusHandle)
1159             {
1160                 return true;
1161             }
1162         }
1163         else
1164         {
1165             // Entity association PDRs does not have terminus handle
1166             return true;
1167         }
1168 
1169         return false;
1170     }
1171 
1172     void printTerminusLocatorPDR(const uint8_t* data, ordered_json& output)
1173     {
1174         const std::array<std::string_view, 4> terminusLocatorType = {
1175             "UID", "MCTP_EID", "SMBusRelative", "systemSoftware"};
1176 
1177         auto pdr = reinterpret_cast<const pldm_terminus_locator_pdr*>(data);
1178 
1179         output["PLDMTerminusHandle"] = pdr->terminus_handle;
1180         output["validity"] = (pdr->validity ? "valid" : "notValid");
1181         output["TID"] = unsigned(pdr->tid);
1182         output["containerID"] = pdr->container_id;
1183         output["terminusLocatorType"] =
1184             terminusLocatorType[pdr->terminus_locator_type];
1185         output["terminusLocatorValueSize"] =
1186             unsigned(pdr->terminus_locator_value_size);
1187 
1188         if (pdr->terminus_locator_type == PLDM_TERMINUS_LOCATOR_TYPE_MCTP_EID)
1189         {
1190             auto locatorValue =
1191                 reinterpret_cast<const pldm_terminus_locator_type_mctp_eid*>(
1192                     pdr->terminus_locator_value);
1193             output["EID"] = unsigned(locatorValue->eid);
1194         }
1195     }
1196 
1197     std::optional<uint16_t> getTerminusHandle(uint8_t* data,
1198                                               std::optional<uint8_t> tid)
1199     {
1200         struct pldm_pdr_hdr* pdr = (struct pldm_pdr_hdr*)data;
1201         if (pdr->type == PLDM_TERMINUS_LOCATOR_PDR)
1202         {
1203             auto pdr = reinterpret_cast<const pldm_terminus_locator_pdr*>(data);
1204             if (pdr->tid == tid)
1205             {
1206                 handleFound = true;
1207                 return pdr->terminus_handle;
1208             }
1209         }
1210         return std::nullopt;
1211     }
1212 
1213     /** @brief Format the Numeric Sensor PDR types to json output
1214      *
1215      *  @param[in] data - reference to the Numeric Sensor PDR
1216      *  @param[in] data_length - number of PDR data bytes
1217      *  @param[out] output - PDRs data fields in Json format
1218      */
1219     void printNumericSensorPDR(const uint8_t* data, const uint16_t data_length,
1220                                ordered_json& output)
1221     {
1222         struct pldm_numeric_sensor_value_pdr pdr;
1223         int rc = decode_numeric_sensor_pdr_data(data, (size_t)data_length,
1224                                                 &pdr);
1225         if (rc != PLDM_SUCCESS)
1226         {
1227             std::cerr << "Failed to get numeric sensor PDR" << std::endl;
1228             return;
1229         }
1230         output["PLDMTerminusHandle"] = pdr.terminus_handle;
1231         output["sensorID"] = pdr.sensor_id;
1232         output["entityType"] = getEntityName(pdr.entity_type);
1233         output["entityInstanceNumber"] = pdr.entity_instance_num;
1234         output["containerID"] = pdr.container_id;
1235         output["sensorInit"] = pdr.sensor_init;
1236         output["sensorAuxiliaryNamesPDR"] =
1237             (pdr.sensor_auxiliary_names_pdr) ? true : false;
1238         output["baseUnit"] = pdr.base_unit;
1239         output["unitModifier"] = pdr.unit_modifier;
1240         output["rateUnit"] = pdr.rate_unit;
1241         output["baseOEMUnitHandle"] = pdr.base_oem_unit_handle;
1242         output["auxUnit"] = pdr.aux_unit;
1243         output["auxUnitModifier"] = pdr.aux_unit_modifier;
1244         output["auxrateUnit"] = pdr.aux_rate_unit;
1245         output["rel"] = pdr.rel;
1246         output["auxOEMUnitHandle"] = pdr.aux_oem_unit_handle;
1247         output["isLinear"] = (pdr.is_linear) ? true : false;
1248         output["sensorDataSize"] = pdr.sensor_data_size;
1249         output["resolution"] = pdr.resolution;
1250         output["offset"] = pdr.offset;
1251         output["accuracy"] = pdr.accuracy;
1252         output["plusTolerance"] = pdr.plus_tolerance;
1253         output["minusTolerance"] = pdr.minus_tolerance;
1254 
1255         switch (pdr.sensor_data_size)
1256         {
1257             case PLDM_SENSOR_DATA_SIZE_UINT8:
1258                 output["hysteresis"] = pdr.hysteresis.value_u8;
1259                 output["maxReadable"] = pdr.max_readable.value_u8;
1260                 output["minReadable"] = pdr.min_readable.value_u8;
1261                 break;
1262             case PLDM_SENSOR_DATA_SIZE_SINT8:
1263                 output["hysteresis"] = pdr.hysteresis.value_s8;
1264                 output["maxReadable"] = pdr.max_readable.value_s8;
1265                 output["minReadable"] = pdr.min_readable.value_s8;
1266                 break;
1267             case PLDM_SENSOR_DATA_SIZE_UINT16:
1268                 output["hysteresis"] = pdr.hysteresis.value_u16;
1269                 output["maxReadable"] = pdr.max_readable.value_u16;
1270                 output["minReadable"] = pdr.min_readable.value_u16;
1271                 break;
1272             case PLDM_SENSOR_DATA_SIZE_SINT16:
1273                 output["hysteresis"] = pdr.hysteresis.value_s16;
1274                 output["maxReadable"] = pdr.max_readable.value_s16;
1275                 output["minReadable"] = pdr.min_readable.value_s16;
1276                 break;
1277             case PLDM_SENSOR_DATA_SIZE_UINT32:
1278                 output["hysteresis"] = pdr.hysteresis.value_u32;
1279                 output["maxReadable"] = pdr.max_readable.value_u32;
1280                 output["minReadable"] = pdr.min_readable.value_u32;
1281                 break;
1282             case PLDM_SENSOR_DATA_SIZE_SINT32:
1283                 output["hysteresis"] = pdr.hysteresis.value_s32;
1284                 output["maxReadable"] = pdr.max_readable.value_s32;
1285                 output["minReadable"] = pdr.min_readable.value_s32;
1286                 break;
1287             default:
1288                 break;
1289         }
1290 
1291         output["supportedThresholds"] = pdr.supported_thresholds.byte;
1292         output["thresholAndHysteresisVolatility"] =
1293             pdr.threshold_and_hysteresis_volatility.byte;
1294         output["stateTransitionInterval"] = pdr.state_transition_interval;
1295         output["updateInterval"] = pdr.update_interval;
1296         output["rangeFieldFormat"] = pdr.range_field_format;
1297         output["rangeFieldSupport"] = pdr.range_field_support.byte;
1298 
1299         switch (pdr.range_field_format)
1300         {
1301             case PLDM_RANGE_FIELD_FORMAT_UINT8:
1302                 output["nominalValue"] = pdr.nominal_value.value_u8;
1303                 output["normalMax"] = pdr.normal_max.value_u8;
1304                 output["normalMin"] = pdr.normal_min.value_u8;
1305                 output["warningHigh"] = pdr.warning_high.value_u8;
1306                 output["warningLow"] = pdr.warning_low.value_u8;
1307                 output["criticalHigh"] = pdr.critical_high.value_u8;
1308                 output["criticalLow"] = pdr.critical_low.value_u8;
1309                 output["fatalHigh"] = pdr.fatal_high.value_u8;
1310                 output["fatalLeow"] = pdr.fatal_low.value_u8;
1311                 break;
1312             case PLDM_RANGE_FIELD_FORMAT_SINT8:
1313                 output["nominalValue"] = pdr.nominal_value.value_s8;
1314                 output["normalMax"] = pdr.normal_max.value_s8;
1315                 output["normalMin"] = pdr.normal_min.value_s8;
1316                 output["warningHigh"] = pdr.warning_high.value_s8;
1317                 output["warningLow"] = pdr.warning_low.value_s8;
1318                 output["criticalHigh"] = pdr.critical_high.value_s8;
1319                 output["criticalLow"] = pdr.critical_low.value_s8;
1320                 output["fatalHigh"] = pdr.fatal_high.value_s8;
1321                 output["fatalLeow"] = pdr.fatal_low.value_s8;
1322                 break;
1323             case PLDM_RANGE_FIELD_FORMAT_UINT16:
1324                 output["nominalValue"] = pdr.nominal_value.value_u16;
1325                 output["normalMax"] = pdr.normal_max.value_u16;
1326                 output["normalMin"] = pdr.normal_min.value_u16;
1327                 output["warningHigh"] = pdr.warning_high.value_u16;
1328                 output["warningLow"] = pdr.warning_low.value_u16;
1329                 output["criticalHigh"] = pdr.critical_high.value_u16;
1330                 output["criticalLow"] = pdr.critical_low.value_u16;
1331                 output["fatalHigh"] = pdr.fatal_high.value_u16;
1332                 output["fatalLeow"] = pdr.fatal_low.value_u16;
1333                 break;
1334             case PLDM_RANGE_FIELD_FORMAT_SINT16:
1335                 output["nominalValue"] = pdr.nominal_value.value_s16;
1336                 output["normalMax"] = pdr.normal_max.value_s16;
1337                 output["normalMin"] = pdr.normal_min.value_s16;
1338                 output["warningHigh"] = pdr.warning_high.value_s16;
1339                 output["warningLow"] = pdr.warning_low.value_s16;
1340                 output["criticalHigh"] = pdr.critical_high.value_s16;
1341                 output["criticalLow"] = pdr.critical_low.value_s16;
1342                 output["fatalHigh"] = pdr.fatal_high.value_s16;
1343                 output["fatalLeow"] = pdr.fatal_low.value_s16;
1344                 break;
1345             case PLDM_RANGE_FIELD_FORMAT_UINT32:
1346                 output["nominalValue"] = pdr.nominal_value.value_u32;
1347                 output["normalMax"] = pdr.normal_max.value_u32;
1348                 output["normalMin"] = pdr.normal_min.value_u32;
1349                 output["warningHigh"] = pdr.warning_high.value_u32;
1350                 output["warningLow"] = pdr.warning_low.value_u32;
1351                 output["criticalHigh"] = pdr.critical_high.value_u32;
1352                 output["criticalLow"] = pdr.critical_low.value_u32;
1353                 output["fatalHigh"] = pdr.fatal_high.value_u32;
1354                 output["fatalLeow"] = pdr.fatal_low.value_u32;
1355                 break;
1356             case PLDM_RANGE_FIELD_FORMAT_SINT32:
1357                 output["nominalValue"] = pdr.nominal_value.value_s32;
1358                 output["normalMax"] = pdr.normal_max.value_s32;
1359                 output["normalMin"] = pdr.normal_min.value_s32;
1360                 output["warningHigh"] = pdr.warning_high.value_s32;
1361                 output["warningLow"] = pdr.warning_low.value_s32;
1362                 output["criticalHigh"] = pdr.critical_high.value_s32;
1363                 output["criticalLow"] = pdr.critical_low.value_s32;
1364                 output["fatalHigh"] = pdr.fatal_high.value_s32;
1365                 output["fatalLeow"] = pdr.fatal_low.value_s32;
1366                 break;
1367             case PLDM_RANGE_FIELD_FORMAT_REAL32:
1368                 output["nominalValue"] = pdr.nominal_value.value_f32;
1369                 output["normalMax"] = pdr.normal_max.value_f32;
1370                 output["normalMin"] = pdr.normal_min.value_f32;
1371                 output["warningHigh"] = pdr.warning_high.value_f32;
1372                 output["warningLow"] = pdr.warning_low.value_f32;
1373                 output["criticalHigh"] = pdr.critical_high.value_f32;
1374                 output["criticalLow"] = pdr.critical_low.value_f32;
1375                 output["fatalHigh"] = pdr.fatal_high.value_f32;
1376                 output["fatalLeow"] = pdr.fatal_low.value_f32;
1377                 break;
1378             default:
1379                 break;
1380         }
1381     }
1382 
1383     /** @brief Format the Compact Numeric Sensor PDR types to json output
1384      *
1385      *  @param[in] data - reference to the Compact Numeric Sensor PDR
1386      *  @param[out] output - PDRs data fields in Json format
1387      */
1388     void printCompactNumericSensorPDR(const uint8_t* data, ordered_json& output)
1389     {
1390         struct pldm_compact_numeric_sensor_pdr* pdr =
1391             (struct pldm_compact_numeric_sensor_pdr*)data;
1392         if (!pdr)
1393         {
1394             std::cerr << "Failed to get compact numeric sensor PDR"
1395                       << std::endl;
1396             return;
1397         }
1398         output["PLDMTerminusHandle"] = int(pdr->terminus_handle);
1399         output["sensorID"] = int(pdr->sensor_id);
1400         output["entityType"] = getEntityName(pdr->entity_type);
1401         output["entityInstanceNumber"] = int(pdr->entity_instance);
1402         output["containerID"] = int(pdr->container_id);
1403         output["sensorNameStringByteLength"] = int(pdr->sensor_name_length);
1404         if (pdr->sensor_name_length == 0)
1405         {
1406             output["Name"] = std::format("PLDM_Device_TID{}_SensorId{}",
1407                                          unsigned(pdr->terminus_handle),
1408                                          unsigned(pdr->sensor_id));
1409         }
1410         else
1411         {
1412             std::string sTemp(reinterpret_cast<const char*>(pdr->sensor_name),
1413                               pdr->sensor_name_length);
1414             output["Name"] = sTemp;
1415         }
1416         output["baseUnit"] = unsigned(pdr->base_unit);
1417         output["unitModifier"] = signed(pdr->unit_modifier);
1418         output["occurrenceRate"] = unsigned(pdr->occurrence_rate);
1419         output["rangeFieldSupport"] = unsigned(pdr->range_field_support.byte);
1420         if (pdr->range_field_support.bits.bit0)
1421         {
1422             output["warningHigh"] = int(pdr->warning_high);
1423         }
1424         if (pdr->range_field_support.bits.bit1)
1425         {
1426             output["warningLow"] = int(pdr->warning_low);
1427         }
1428         if (pdr->range_field_support.bits.bit2)
1429         {
1430             output["criticalHigh"] = int(pdr->critical_high);
1431         }
1432         if (pdr->range_field_support.bits.bit3)
1433         {
1434             output["criticalLow"] = int(pdr->critical_low);
1435         }
1436         if (pdr->range_field_support.bits.bit4)
1437         {
1438             output["fatalHigh"] = int(pdr->fatal_high);
1439         }
1440         if (pdr->range_field_support.bits.bit5)
1441         {
1442             output["fatalLow"] = int(pdr->fatal_low);
1443         }
1444     }
1445 
1446     void printPDRMsg(uint32_t& nextRecordHndl, const uint16_t respCnt,
1447                      uint8_t* data, std::optional<uint16_t> terminusHandle)
1448     {
1449         if (data == NULL)
1450         {
1451             std::cerr << "Failed to get PDR message" << std::endl;
1452             return;
1453         }
1454 
1455         ordered_json output;
1456         output["nextRecordHandle"] = nextRecordHndl;
1457         output["responseCount"] = respCnt;
1458 
1459         struct pldm_pdr_hdr* pdr = (struct pldm_pdr_hdr*)data;
1460         if (!pdr)
1461         {
1462             return;
1463         }
1464 
1465         if (!pdrRecType.empty())
1466         {
1467             // Need to return if the requested PDR type
1468             // is not supported
1469             if (!strToPdrType.contains(pdrRecType))
1470             {
1471                 std::cerr << "PDR type '" << pdrRecType
1472                           << "' is not supported or invalid\n";
1473                 // PDR type not supported, setting next record handle to
1474                 // 0 to avoid looping through all PDR records
1475                 nextRecordHndl = 0;
1476                 return;
1477             }
1478 
1479             // Do not print PDR record if the current record
1480             // PDR type does not match with requested type
1481             if (pdr->type != strToPdrType.at(pdrRecType))
1482             {
1483                 return;
1484             }
1485         }
1486 
1487         if (pdrTerminus.has_value())
1488         {
1489             if (checkTerminusHandle(data, terminusHandle))
1490             {
1491                 std::cerr << "The Terminus handle doesn't match return"
1492                           << std::endl;
1493                 return;
1494             }
1495         }
1496 
1497         printCommonPDRHeader(pdr, output);
1498 
1499         switch (pdr->type)
1500         {
1501             case PLDM_TERMINUS_LOCATOR_PDR:
1502                 printTerminusLocatorPDR(data, output);
1503                 break;
1504             case PLDM_STATE_SENSOR_PDR:
1505                 printStateSensorPDR(data, output);
1506                 break;
1507             case PLDM_NUMERIC_EFFECTER_PDR:
1508                 printNumericEffecterPDR(data, output);
1509                 break;
1510             case PLDM_NUMERIC_SENSOR_PDR:
1511                 printNumericSensorPDR(data, respCnt, output);
1512                 break;
1513             case PLDM_SENSOR_AUXILIARY_NAMES_PDR:
1514                 printAuxNamePDR(data, output);
1515                 break;
1516             case PLDM_EFFECTER_AUXILIARY_NAMES_PDR:
1517                 printAuxNamePDR(data, output);
1518                 break;
1519             case PLDM_STATE_EFFECTER_PDR:
1520                 printStateEffecterPDR(data, output);
1521                 break;
1522             case PLDM_PDR_ENTITY_ASSOCIATION:
1523                 printPDREntityAssociation(data, output);
1524                 break;
1525             case PLDM_PDR_FRU_RECORD_SET:
1526                 printPDRFruRecordSet(data, output);
1527                 break;
1528             case PLDM_COMPACT_NUMERIC_SENSOR_PDR:
1529                 printCompactNumericSensorPDR(data, output);
1530                 break;
1531             default:
1532                 break;
1533         }
1534         pldmtool::helper::DisplayInJson(output);
1535     }
1536 
1537   private:
1538     bool optTIDSet = false;
1539     uint32_t recordHandle;
1540     bool allPDRs;
1541     std::string pdrRecType;
1542     std::optional<uint8_t> pdrTerminus;
1543     std::optional<uint16_t> terminusHandle;
1544     bool handleFound = false;
1545     CLI::Option* getPDRGroupOption = nullptr;
1546 };
1547 
1548 class SetStateEffecter : public CommandInterface
1549 {
1550   public:
1551     ~SetStateEffecter() = default;
1552     SetStateEffecter() = delete;
1553     SetStateEffecter(const SetStateEffecter&) = delete;
1554     SetStateEffecter(SetStateEffecter&&) = default;
1555     SetStateEffecter& operator=(const SetStateEffecter&) = delete;
1556     SetStateEffecter& operator=(SetStateEffecter&&) = delete;
1557 
1558     // compositeEffecterCount(value: 0x01 to 0x08) * stateField(2)
1559     static constexpr auto maxEffecterDataSize = 16;
1560 
1561     // compositeEffecterCount(value: 0x01 to 0x08)
1562     static constexpr auto minEffecterCount = 1;
1563     static constexpr auto maxEffecterCount = 8;
1564     explicit SetStateEffecter(const char* type, const char* name,
1565                               CLI::App* app) :
1566         CommandInterface(type, name, app)
1567     {
1568         app->add_option(
1569                "-i, --id", effecterId,
1570                "A handle that is used to identify and access the effecter")
1571             ->required();
1572         app->add_option("-c, --count", effecterCount,
1573                         "The number of individual sets of effecter information")
1574             ->required();
1575         app->add_option(
1576                "-d,--data", effecterData,
1577                "Set effecter state data\n"
1578                "eg: requestSet0 effecterState0 noChange1 dummyState1 ...")
1579             ->required();
1580     }
1581 
1582     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
1583     {
1584         std::vector<uint8_t> requestMsg(
1585             sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES);
1586         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1587 
1588         if (effecterCount > maxEffecterCount ||
1589             effecterCount < minEffecterCount)
1590         {
1591             std::cerr << "Request Message Error: effecterCount size "
1592                       << effecterCount << "is invalid\n";
1593             auto rc = PLDM_ERROR_INVALID_DATA;
1594             return {rc, requestMsg};
1595         }
1596 
1597         if (effecterData.size() > maxEffecterDataSize)
1598         {
1599             std::cerr << "Request Message Error: effecterData size "
1600                       << effecterData.size() << "is invalid\n";
1601             auto rc = PLDM_ERROR_INVALID_DATA;
1602             return {rc, requestMsg};
1603         }
1604 
1605         auto stateField = parseEffecterData(effecterData, effecterCount);
1606         if (!stateField)
1607         {
1608             std::cerr << "Failed to parse effecter data, effecterCount size "
1609                       << effecterCount << "\n";
1610             auto rc = PLDM_ERROR_INVALID_DATA;
1611             return {rc, requestMsg};
1612         }
1613 
1614         auto rc = encode_set_state_effecter_states_req(
1615             instanceId, effecterId, effecterCount, stateField->data(), request);
1616         return {rc, requestMsg};
1617     }
1618 
1619     void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
1620     {
1621         uint8_t completionCode = 0;
1622         auto rc = decode_set_state_effecter_states_resp(
1623             responsePtr, payloadLength, &completionCode);
1624 
1625         if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
1626         {
1627             std::cerr << "Response Message Error: "
1628                       << "rc=" << rc << ",cc=" << (int)completionCode << "\n";
1629             return;
1630         }
1631 
1632         ordered_json data;
1633         data["Response"] = "SUCCESS";
1634         pldmtool::helper::DisplayInJson(data);
1635     }
1636 
1637   private:
1638     uint16_t effecterId;
1639     uint8_t effecterCount;
1640     std::vector<uint8_t> effecterData;
1641 };
1642 
1643 class SetNumericEffecterValue : public CommandInterface
1644 {
1645   public:
1646     ~SetNumericEffecterValue() = default;
1647     SetNumericEffecterValue() = delete;
1648     SetNumericEffecterValue(const SetNumericEffecterValue&) = delete;
1649     SetNumericEffecterValue(SetNumericEffecterValue&&) = default;
1650     SetNumericEffecterValue& operator=(const SetNumericEffecterValue&) = delete;
1651     SetNumericEffecterValue& operator=(SetNumericEffecterValue&&) = delete;
1652 
1653     explicit SetNumericEffecterValue(const char* type, const char* name,
1654                                      CLI::App* app) :
1655         CommandInterface(type, name, app)
1656     {
1657         app->add_option(
1658                "-i, --id", effecterId,
1659                "A handle that is used to identify and access the effecter")
1660             ->required();
1661         app->add_option("-s, --size", effecterDataSize,
1662                         "The bit width and format of the setting value for the "
1663                         "effecter. enum value: {uint8, sint8, uint16, sint16, "
1664                         "uint32, sint32}\n")
1665             ->required();
1666         app->add_option("-d,--data", maxEffecterValue,
1667                         "The setting value of numeric effecter being "
1668                         "requested\n")
1669             ->required();
1670     }
1671 
1672     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
1673     {
1674         std::vector<uint8_t> requestMsg(
1675             sizeof(pldm_msg_hdr) +
1676             PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES + 3);
1677 
1678         uint8_t* effecterValue = (uint8_t*)&maxEffecterValue;
1679 
1680         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1681         size_t payload_length = PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES;
1682 
1683         if (effecterDataSize == PLDM_EFFECTER_DATA_SIZE_UINT16 ||
1684             effecterDataSize == PLDM_EFFECTER_DATA_SIZE_SINT16)
1685         {
1686             payload_length = PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES + 1;
1687         }
1688         if (effecterDataSize == PLDM_EFFECTER_DATA_SIZE_UINT32 ||
1689             effecterDataSize == PLDM_EFFECTER_DATA_SIZE_SINT32)
1690         {
1691             payload_length = PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES + 3;
1692         }
1693         auto rc = encode_set_numeric_effecter_value_req(
1694             0, effecterId, effecterDataSize, effecterValue, request,
1695             payload_length);
1696 
1697         return {rc, requestMsg};
1698     }
1699 
1700     void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
1701     {
1702         uint8_t completionCode = 0;
1703         auto rc = decode_set_numeric_effecter_value_resp(
1704             responsePtr, payloadLength, &completionCode);
1705 
1706         if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
1707         {
1708             std::cerr << "Response Message Error: "
1709                       << "rc=" << rc << ",cc=" << (int)completionCode
1710                       << std::endl;
1711             return;
1712         }
1713 
1714         ordered_json data;
1715         data["Response"] = "SUCCESS";
1716         pldmtool::helper::DisplayInJson(data);
1717     }
1718 
1719   private:
1720     uint16_t effecterId;
1721     uint8_t effecterDataSize;
1722     uint64_t maxEffecterValue;
1723 };
1724 
1725 class GetStateSensorReadings : public CommandInterface
1726 {
1727   public:
1728     ~GetStateSensorReadings() = default;
1729     GetStateSensorReadings() = delete;
1730     GetStateSensorReadings(const GetStateSensorReadings&) = delete;
1731     GetStateSensorReadings(GetStateSensorReadings&&) = default;
1732     GetStateSensorReadings& operator=(const GetStateSensorReadings&) = delete;
1733     GetStateSensorReadings& operator=(GetStateSensorReadings&&) = delete;
1734 
1735     explicit GetStateSensorReadings(const char* type, const char* name,
1736                                     CLI::App* app) :
1737         CommandInterface(type, name, app)
1738     {
1739         app->add_option(
1740                "-i, --sensor_id", sensorId,
1741                "Sensor ID that is used to identify and access the sensor")
1742             ->required();
1743         app->add_option("-r, --rearm", sensorRearm,
1744                         "Each bit location in this field corresponds to a "
1745                         "particular sensor")
1746             ->required();
1747     }
1748 
1749     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
1750     {
1751         std::vector<uint8_t> requestMsg(
1752             sizeof(pldm_msg_hdr) + PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES);
1753         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1754 
1755         uint8_t reserved = 0;
1756         bitfield8_t bf;
1757         bf.byte = sensorRearm;
1758         auto rc = encode_get_state_sensor_readings_req(instanceId, sensorId, bf,
1759                                                        reserved, request);
1760 
1761         return {rc, requestMsg};
1762     }
1763 
1764     void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
1765     {
1766         uint8_t completionCode = 0;
1767         uint8_t compSensorCount = 0;
1768         std::array<get_sensor_state_field, 8> stateField{};
1769         auto rc = decode_get_state_sensor_readings_resp(
1770             responsePtr, payloadLength, &completionCode, &compSensorCount,
1771             stateField.data());
1772 
1773         if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
1774         {
1775             std::cerr << "Response Message Error: "
1776                       << "rc=" << rc << ",cc=" << (int)completionCode
1777                       << std::endl;
1778             return;
1779         }
1780         ordered_json output;
1781         output["compositeSensorCount"] = (int)compSensorCount;
1782 
1783         for (size_t i = 0; i < compSensorCount; i++)
1784         {
1785             if (sensorOpState.contains(stateField[i].sensor_op_state))
1786             {
1787                 output.emplace(("sensorOpState[" + std::to_string(i) + "]"),
1788                                sensorOpState.at(stateField[i].sensor_op_state));
1789             }
1790 
1791             if (sensorPresState.contains(stateField[i].present_state))
1792             {
1793                 output.emplace(("presentState[" + std::to_string(i) + "]"),
1794                                sensorPresState.at(stateField[i].present_state));
1795             }
1796 
1797             if (sensorPresState.contains(stateField[i].previous_state))
1798             {
1799                 output.emplace(
1800                     ("previousState[" + std::to_string(i) + "]"),
1801                     sensorPresState.at(stateField[i].previous_state));
1802             }
1803 
1804             if (sensorPresState.contains(stateField[i].event_state))
1805             {
1806                 output.emplace(("eventState[" + std::to_string(i) + "]"),
1807                                sensorPresState.at(stateField[i].event_state));
1808             }
1809         }
1810 
1811         pldmtool::helper::DisplayInJson(output);
1812     }
1813 
1814   private:
1815     uint16_t sensorId;
1816     uint8_t sensorRearm;
1817 };
1818 
1819 class GetSensorReading : public CommandInterface
1820 {
1821   public:
1822     ~GetSensorReading() = default;
1823     GetSensorReading() = delete;
1824     GetSensorReading(const GetSensorReading&) = delete;
1825     GetSensorReading(GetSensorReading&&) = default;
1826     GetSensorReading& operator=(const GetSensorReading&) = delete;
1827     GetSensorReading& operator=(GetSensorReading&&) = delete;
1828 
1829     explicit GetSensorReading(const char* type, const char* name,
1830                               CLI::App* app) :
1831         CommandInterface(type, name, app)
1832     {
1833         app->add_option(
1834                "-i, --sensor_id", sensorId,
1835                "Sensor ID that is used to identify and access the sensor")
1836             ->required();
1837         app->add_option("-r, --rearm", rearm,
1838                         "Manually re-arm EventState after "
1839                         "responding to this request")
1840             ->required();
1841     }
1842 
1843     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
1844     {
1845         std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
1846                                         PLDM_GET_SENSOR_READING_REQ_BYTES);
1847         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1848 
1849         auto rc = encode_get_sensor_reading_req(instanceId, sensorId, rearm,
1850                                                 request);
1851 
1852         return {rc, requestMsg};
1853     }
1854 
1855     void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
1856     {
1857         uint8_t completionCode = 0;
1858         uint8_t sensorDataSize = 0;
1859         uint8_t sensorOperationalState = 0;
1860         uint8_t sensorEventMessageEnable = 0;
1861         uint8_t presentState = 0;
1862         uint8_t previousState = 0;
1863         uint8_t eventState = 0;
1864         std::array<uint8_t, sizeof(uint32_t)>
1865             presentReading{}; // maximum size for the present Value is uint32
1866                               // according to spec DSP0248
1867 
1868         auto rc = decode_get_sensor_reading_resp(
1869             responsePtr, payloadLength, &completionCode, &sensorDataSize,
1870             &sensorOperationalState, &sensorEventMessageEnable, &presentState,
1871             &previousState, &eventState, presentReading.data());
1872 
1873         if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
1874         {
1875             std::cerr << "Response Message Error: "
1876                       << "rc=" << rc << ",cc=" << (int)completionCode
1877                       << std::endl;
1878             return;
1879         }
1880 
1881         ordered_json output;
1882         output["sensorDataSize"] = getSensorState(sensorDataSize,
1883                                                   &sensorDataSz);
1884         output["sensorOperationalState"] =
1885             getSensorState(sensorOperationalState, &sensorOpState);
1886         output["sensorEventMessageEnable"] =
1887             getSensorState(sensorEventMessageEnable, &sensorEventMsgEnable);
1888         output["presentState"] = getSensorState(presentState, &sensorPresState);
1889         output["previousState"] = getSensorState(previousState,
1890                                                  &sensorPresState);
1891         output["eventState"] = getSensorState(eventState, &sensorPresState);
1892 
1893         switch (sensorDataSize)
1894         {
1895             case PLDM_SENSOR_DATA_SIZE_UINT8:
1896             {
1897                 output["presentReading"] =
1898                     *(reinterpret_cast<uint8_t*>(presentReading.data()));
1899                 break;
1900             }
1901             case PLDM_SENSOR_DATA_SIZE_SINT8:
1902             {
1903                 output["presentReading"] =
1904                     *(reinterpret_cast<int8_t*>(presentReading.data()));
1905                 break;
1906             }
1907             case PLDM_SENSOR_DATA_SIZE_UINT16:
1908             {
1909                 output["presentReading"] =
1910                     *(reinterpret_cast<uint16_t*>(presentReading.data()));
1911                 break;
1912             }
1913             case PLDM_SENSOR_DATA_SIZE_SINT16:
1914             {
1915                 output["presentReading"] =
1916                     *(reinterpret_cast<int16_t*>(presentReading.data()));
1917                 break;
1918             }
1919             case PLDM_SENSOR_DATA_SIZE_UINT32:
1920             {
1921                 output["presentReading"] =
1922                     *(reinterpret_cast<uint32_t*>(presentReading.data()));
1923                 break;
1924             }
1925             case PLDM_SENSOR_DATA_SIZE_SINT32:
1926             {
1927                 output["presentReading"] =
1928                     *(reinterpret_cast<int32_t*>(presentReading.data()));
1929                 break;
1930             }
1931             default:
1932             {
1933                 std::cerr << "Unknown Sensor Data Size : "
1934                           << static_cast<int>(sensorDataSize) << std::endl;
1935                 break;
1936             }
1937         }
1938 
1939         pldmtool::helper::DisplayInJson(output);
1940     }
1941 
1942   private:
1943     uint16_t sensorId;
1944     uint8_t rearm;
1945 
1946     const std::map<uint8_t, std::string> sensorDataSz = {
1947         {PLDM_SENSOR_DATA_SIZE_UINT8, "uint8"},
1948         {PLDM_SENSOR_DATA_SIZE_SINT8, "uint8"},
1949         {PLDM_SENSOR_DATA_SIZE_UINT16, "uint16"},
1950         {PLDM_SENSOR_DATA_SIZE_SINT16, "uint16"},
1951         {PLDM_SENSOR_DATA_SIZE_UINT32, "uint32"},
1952         {PLDM_SENSOR_DATA_SIZE_SINT32, "uint32"}};
1953 
1954     static inline const std::map<uint8_t, std::string> sensorEventMsgEnable{
1955         {PLDM_NO_EVENT_GENERATION, "Sensor No Event Generation"},
1956         {PLDM_EVENTS_DISABLED, "Sensor Events Disabled"},
1957         {PLDM_EVENTS_ENABLED, "Sensor Events Enabled"},
1958         {PLDM_OP_EVENTS_ONLY_ENABLED, "Sensor Op Events Only Enabled"},
1959         {PLDM_STATE_EVENTS_ONLY_ENABLED, "Sensor State Events Only Enabled"}};
1960 
1961     std::string getSensorState(uint8_t state,
1962                                const std::map<uint8_t, std::string>* cont)
1963     {
1964         auto typeString = std::to_string(state);
1965         try
1966         {
1967             return cont->at(state);
1968         }
1969         catch (const std::out_of_range& e)
1970         {
1971             return typeString;
1972         }
1973     }
1974 };
1975 
1976 class GetNumericEffecterValue : public CommandInterface
1977 {
1978   public:
1979     ~GetNumericEffecterValue() = default;
1980     GetNumericEffecterValue() = delete;
1981     GetNumericEffecterValue(const GetNumericEffecterValue&) = delete;
1982     GetNumericEffecterValue(GetNumericEffecterValue&&) = default;
1983     GetNumericEffecterValue& operator=(const GetNumericEffecterValue&) = delete;
1984     GetNumericEffecterValue& operator=(GetNumericEffecterValue&&) = delete;
1985 
1986     explicit GetNumericEffecterValue(const char* type, const char* name,
1987                                      CLI::App* app) :
1988         CommandInterface(type, name, app)
1989     {
1990         app->add_option(
1991                "-i, --effecter_id", effecterId,
1992                "A handle that is used to identify and access the effecter")
1993             ->required();
1994     }
1995 
1996     std::pair<int, std::vector<uint8_t>> createRequestMsg() override
1997     {
1998         std::vector<uint8_t> requestMsg(
1999             sizeof(pldm_msg_hdr) + PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES);
2000         auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
2001 
2002         auto rc = encode_get_numeric_effecter_value_req(instanceId, effecterId,
2003                                                         request);
2004 
2005         return {rc, requestMsg};
2006     }
2007 
2008     void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
2009     {
2010         uint8_t completionCode = 0;
2011         uint8_t effecterDataSize = 0;
2012         uint8_t effecterOperationalState = 0;
2013         std::array<uint8_t, sizeof(uint32_t)>
2014             pendingValue{}; // maximum size for the pending Value is uint32
2015                             // according to spec DSP0248
2016         std::array<uint8_t, sizeof(uint32_t)>
2017             presentValue{}; // maximum size for the present Value is uint32
2018                             // according to spec DSP0248
2019 
2020         auto rc = decode_get_numeric_effecter_value_resp(
2021             responsePtr, payloadLength, &completionCode, &effecterDataSize,
2022             &effecterOperationalState, pendingValue.data(),
2023             presentValue.data());
2024 
2025         if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
2026         {
2027             std::cerr << "Response Message Error: "
2028                       << "rc=" << rc
2029                       << ",cc=" << static_cast<int>(completionCode)
2030                       << std::endl;
2031             return;
2032         }
2033 
2034         ordered_json output;
2035         output["effecterDataSize"] = static_cast<int>(effecterDataSize);
2036         output["effecterOperationalState"] =
2037             getOpState(effecterOperationalState);
2038 
2039         switch (effecterDataSize)
2040         {
2041             case PLDM_EFFECTER_DATA_SIZE_UINT8:
2042             {
2043                 output["pendingValue"] =
2044                     *(reinterpret_cast<uint8_t*>(pendingValue.data()));
2045                 output["presentValue"] =
2046                     *(reinterpret_cast<uint8_t*>(presentValue.data()));
2047                 break;
2048             }
2049             case PLDM_EFFECTER_DATA_SIZE_SINT8:
2050             {
2051                 output["pendingValue"] =
2052                     *(reinterpret_cast<int8_t*>(pendingValue.data()));
2053                 output["presentValue"] =
2054                     *(reinterpret_cast<int8_t*>(presentValue.data()));
2055                 break;
2056             }
2057             case PLDM_EFFECTER_DATA_SIZE_UINT16:
2058             {
2059                 output["pendingValue"] =
2060                     *(reinterpret_cast<uint16_t*>(pendingValue.data()));
2061                 output["presentValue"] =
2062                     *(reinterpret_cast<uint16_t*>(presentValue.data()));
2063                 break;
2064             }
2065             case PLDM_EFFECTER_DATA_SIZE_SINT16:
2066             {
2067                 output["pendingValue"] =
2068                     *(reinterpret_cast<int16_t*>(pendingValue.data()));
2069                 output["presentValue"] =
2070                     *(reinterpret_cast<int16_t*>(presentValue.data()));
2071                 break;
2072             }
2073             case PLDM_EFFECTER_DATA_SIZE_UINT32:
2074             {
2075                 output["pendingValue"] =
2076                     *(reinterpret_cast<uint32_t*>(pendingValue.data()));
2077                 output["presentValue"] =
2078                     *(reinterpret_cast<uint32_t*>(presentValue.data()));
2079                 break;
2080             }
2081             case PLDM_EFFECTER_DATA_SIZE_SINT32:
2082             {
2083                 output["pendingValue"] =
2084                     *(reinterpret_cast<int32_t*>(pendingValue.data()));
2085                 output["presentValue"] =
2086                     *(reinterpret_cast<int32_t*>(presentValue.data()));
2087                 break;
2088             }
2089             default:
2090             {
2091                 std::cerr << "Unknown Effecter Data Size : "
2092                           << static_cast<int>(effecterDataSize) << std::endl;
2093                 break;
2094             }
2095         }
2096 
2097         pldmtool::helper::DisplayInJson(output);
2098     }
2099 
2100   private:
2101     uint16_t effecterId;
2102 
2103     static inline const std::map<uint8_t, std::string> numericEffecterOpState{
2104         {EFFECTER_OPER_STATE_ENABLED_UPDATEPENDING,
2105          "Effecter Enabled Update Pending"},
2106         {EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING,
2107          "Effecter Enabled No Update Pending"},
2108         {EFFECTER_OPER_STATE_DISABLED, "Effecter Disabled"},
2109         {EFFECTER_OPER_STATE_UNAVAILABLE, "Effecter Unavailable"},
2110         {EFFECTER_OPER_STATE_STATUSUNKNOWN, "Effecter Status Unknown"},
2111         {EFFECTER_OPER_STATE_FAILED, "Effecter Failed"},
2112         {EFFECTER_OPER_STATE_INITIALIZING, "Effecter Initializing"},
2113         {EFFECTER_OPER_STATE_SHUTTINGDOWN, "Effecter Shutting Down"},
2114         {EFFECTER_OPER_STATE_INTEST, "Effecter In Test"}};
2115 
2116     std::string getOpState(uint8_t state)
2117     {
2118         auto typeString = std::to_string(state);
2119         try
2120         {
2121             return numericEffecterOpState.at(state);
2122         }
2123         catch (const std::out_of_range& e)
2124         {
2125             return typeString;
2126         }
2127     }
2128 };
2129 
2130 void registerCommand(CLI::App& app)
2131 {
2132     auto platform = app.add_subcommand("platform", "platform type command");
2133     platform->require_subcommand(1);
2134 
2135     auto getPDR = platform->add_subcommand("GetPDR",
2136                                            "get platform descriptor records");
2137     commands.push_back(std::make_unique<GetPDR>("platform", "getPDR", getPDR));
2138 
2139     auto setStateEffecterStates = platform->add_subcommand(
2140         "SetStateEffecterStates", "set effecter states");
2141     commands.push_back(std::make_unique<SetStateEffecter>(
2142         "platform", "setStateEffecterStates", setStateEffecterStates));
2143 
2144     auto setNumericEffecterValue = platform->add_subcommand(
2145         "SetNumericEffecterValue", "set the value for a PLDM Numeric Effecter");
2146     commands.push_back(std::make_unique<SetNumericEffecterValue>(
2147         "platform", "setNumericEffecterValue", setNumericEffecterValue));
2148 
2149     auto getStateSensorReadings = platform->add_subcommand(
2150         "GetStateSensorReadings", "get the state sensor readings");
2151     commands.push_back(std::make_unique<GetStateSensorReadings>(
2152         "platform", "getStateSensorReadings", getStateSensorReadings));
2153 
2154     auto getNumericEffecterValue = platform->add_subcommand(
2155         "GetNumericEffecterValue", "get the numeric effecter value");
2156     commands.push_back(std::make_unique<GetNumericEffecterValue>(
2157         "platform", "getNumericEffecterValue", getNumericEffecterValue));
2158 
2159     auto getSensorReading = platform->add_subcommand(
2160         "GetSensorReading", "get the numeric sensor reading");
2161     commands.push_back(std::make_unique<GetSensorReading>(
2162         "platform", "getSensorReading", getSensorReading));
2163 }
2164 
2165 void parseGetPDROption()
2166 {
2167     for (const auto& command : commands)
2168     {
2169         if (command.get()->getPLDMType() == "platform" &&
2170             command.get()->getCommandName() == "getPDR")
2171         {
2172             auto getPDR = dynamic_cast<GetPDR*>(command.get());
2173             getPDR->parseGetPDROptions();
2174         }
2175     }
2176 }
2177 
2178 } // namespace platform
2179 } // namespace pldmtool
2180