#include "pldm_fru_cmd.hpp"
#include "pldm_cmd_helper.hpp"
#ifdef OEM_IBM
#include <libpldm/fru_oem_ibm.h>
#endif
#include <endian.h>
#include <functional>
#include <tuple>
namespace pldmtool
{
namespace fru
{
namespace
{
using namespace pldmtool::helper;
std::vector<std::unique_ptr<CommandInterface>> commands;
} // namespace
class GetFruRecordTableMetadata : public CommandInterface
{
public:
~GetFruRecordTableMetadata() = default;
GetFruRecordTableMetadata() = delete;
GetFruRecordTableMetadata(const GetFruRecordTableMetadata&) = delete;
GetFruRecordTableMetadata(GetFruRecordTableMetadata&&) = default;
GetFruRecordTableMetadata&
operator=(const GetFruRecordTableMetadata&) = delete;
GetFruRecordTableMetadata& operator=(GetFruRecordTableMetadata&&) = delete;
using CommandInterface::CommandInterface;
std::pair<int, std::vector<uint8_t>> createRequestMsg() override
{
std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr));
auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
auto rc = encode_get_fru_record_table_metadata_req(
instanceId, request, PLDM_GET_FRU_RECORD_TABLE_METADATA_REQ_BYTES);
return {rc, requestMsg};
}
void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
{
uint8_t cc = 0;
uint8_t fru_data_major_version, fru_data_minor_version;
uint32_t fru_table_maximum_size, fru_table_length;
uint16_t total_record_set_identifiers, total_table_records;
uint32_t checksum;
auto rc = decode_get_fru_record_table_metadata_resp(
responsePtr, payloadLength, &cc, &fru_data_major_version,
&fru_data_minor_version, &fru_table_maximum_size, &fru_table_length,
&total_record_set_identifiers, &total_table_records, &checksum);
if (rc != PLDM_SUCCESS || cc != PLDM_SUCCESS)
{
std::cerr << "Response Message Error: "
<< "rc=" << rc << ",cc=" << (int)cc << std::endl;
return;
}
ordered_json output;
output["FRUDATAMajorVersion"] =
static_cast<uint32_t>(fru_data_major_version);
output["FRUDATAMinorVersion"] =
static_cast<uint32_t>(fru_data_minor_version);
output["FRUTableMaximumSize"] = fru_table_maximum_size;
output["FRUTableLength"] = fru_table_length;
output["Total number of Record Set Identifiers in table"] =
total_record_set_identifiers;
output["Total number of records in table"] = total_table_records;
output["FRU DATAStructureTableIntegrityChecksum"] = checksum;
pldmtool::helper::DisplayInJson(output);
}
};
class FRUTablePrint
{
public:
explicit FRUTablePrint(const uint8_t* table, size_t table_size) :
table(table), table_size(table_size)
{}
void print()
{
auto p = table;
ordered_json frutable;
ordered_json output;
while (!isTableEnd(p))
{
auto record =
reinterpret_cast<const pldm_fru_record_data_format*>(p);
output["FRU Record Set Identifier"] =
(int)le16toh(record->record_set_id);
output["FRU Record Type"] = typeToString(fruRecordTypes,
record->record_type);
output["Number of FRU fields"] = (int)record->num_fru_fields;
output["Encoding Type for FRU fields"] =
typeToString(fruEncodingType, record->encoding_type);
p += sizeof(pldm_fru_record_data_format) -
sizeof(pldm_fru_record_tlv);
std::map<uint8_t, std::string> FruFieldTypeMap;
std::string fruFieldValue;
ordered_json frudata;
ordered_json frufielddata;
frufielddata.emplace_back(output);
for (int i = 0; i < record->num_fru_fields; i++)
{
auto tlv = reinterpret_cast<const pldm_fru_record_tlv*>(p);
if (record->record_type == PLDM_FRU_RECORD_TYPE_GENERAL)
{
FruFieldTypeMap.insert(fruGeneralFieldTypes.begin(),
fruGeneralFieldTypes.end());
if (tlv->type == PLDM_FRU_FIELD_TYPE_IANA)
{
fruFieldValue = fruFieldParserU32(tlv->value,
tlv->length);
}
else if (tlv->type == PLDM_FRU_FIELD_TYPE_MANUFAC_DATE)
{
fruFieldValue = fruFieldParserTimestamp(tlv->value,
tlv->length);
}
else
{
fruFieldValue = fruFieldValuestring(tlv->value,
tlv->length);
}
frudata["FRU Field Type"] = typeToString(FruFieldTypeMap,
tlv->type);
frudata["FRU Field Length"] = (int)(tlv->length);
frudata["FRU Field Value"] = fruFieldValue;
frufielddata.emplace_back(frudata);
}
else
{
#ifdef OEM_IBM
if (tlv->type == PLDM_OEM_FRU_FIELD_TYPE_RT)
{
auto oemIPZValue = fruFieldValuestring(tlv->value,
tlv->length);
if (populateMaps.find(oemIPZValue) !=
populateMaps.end())
{
const std::map<uint8_t, std::string> IPZTypes =
populateMaps.at(oemIPZValue);
FruFieldTypeMap.insert(IPZTypes.begin(),
IPZTypes.end());
}
}
else
{
FruFieldTypeMap.insert(fruOemFieldTypes.begin(),
fruOemFieldTypes.end());
}
if (tlv->type == PLDM_OEM_FRU_FIELD_TYPE_IANA)
{
fruFieldValue = fruFieldParserU32(tlv->value,
tlv->length);
}
else if (tlv->type != 2)
{
fruFieldValue = fruFieldIPZParser(tlv->value,
tlv->length);
}
else
{
fruFieldValue = fruFieldValuestring(tlv->value,
tlv->length);
}
frudata["FRU Field Type"] = typeToString(FruFieldTypeMap,
tlv->type);
frudata["FRU Field Length"] = (int)(tlv->length);
frudata["FRU Field Value"] = fruFieldValue;
frufielddata.emplace_back(frudata);
#endif
}
p += sizeof(pldm_fru_record_tlv) - 1 + tlv->length;
}
frutable.emplace_back(frufielddata);
}
pldmtool::helper::DisplayInJson(frutable);
}
private:
const uint8_t* table;
size_t table_size;
bool isTableEnd(const uint8_t* p)
{
auto offset = p - table;
return (table_size - offset) <= 7;
}
static inline const std::map<uint8_t, std::string> fruEncodingType{
{PLDM_FRU_ENCODING_UNSPECIFIED, "Unspecified"},
{PLDM_FRU_ENCODING_ASCII, "ASCII"},
{PLDM_FRU_ENCODING_UTF8, "UTF8"},
{PLDM_FRU_ENCODING_UTF16, "UTF16"},
{PLDM_FRU_ENCODING_UTF16LE, "UTF16LE"},
{PLDM_FRU_ENCODING_UTF16BE, "UTF16BE"}};
static inline const std::map<uint8_t, std::string> fruGeneralFieldTypes{
{PLDM_FRU_FIELD_TYPE_CHASSIS, "Chassis"},
{PLDM_FRU_FIELD_TYPE_MODEL, "Model"},
{PLDM_FRU_FIELD_TYPE_PN, "Part Number"},
{PLDM_FRU_FIELD_TYPE_SN, "Serial Number"},
{PLDM_FRU_FIELD_TYPE_MANUFAC, "Manufacturer"},
{PLDM_FRU_FIELD_TYPE_MANUFAC_DATE, "Manufacture Date"},
{PLDM_FRU_FIELD_TYPE_VENDOR, "Vendor"},
{PLDM_FRU_FIELD_TYPE_NAME, "Name"},
{PLDM_FRU_FIELD_TYPE_SKU, "SKU"},
{PLDM_FRU_FIELD_TYPE_VERSION, "Version"},
{PLDM_FRU_FIELD_TYPE_ASSET_TAG, "Asset Tag"},
{PLDM_FRU_FIELD_TYPE_DESC, "Description"},
{PLDM_FRU_FIELD_TYPE_EC_LVL, "Engineering Change Level"},
{PLDM_FRU_FIELD_TYPE_OTHER, "Other Information"},
{PLDM_FRU_FIELD_TYPE_IANA, "Vendor IANA"}};
static inline const std::map<uint8_t, std::string> fruRecordTypes{
{PLDM_FRU_RECORD_TYPE_GENERAL, "General"},
{PLDM_FRU_RECORD_TYPE_OEM, "OEM"}};
#ifdef OEM_IBM
static inline const std::map<uint8_t, std::string> fruOemFieldTypes{
{PLDM_OEM_FRU_FIELD_TYPE_IANA, "Vendor IANA"},
{PLDM_OEM_FRU_FIELD_TYPE_RT, "RT"},
{PLDM_OEM_FRU_FIELD_TYPE_LOCATION_CODE, "Location Code"}};
static inline const std::map<uint8_t, std::string> VINIFieldTypes{
{2, "RT"}, {3, "B3"}, {4, "B4"}, {5, "B7"}, {6, "CC"}, {7, "CE"},
{8, "CT"}, {9, "DR"}, {10, "FG"}, {11, "FN"}, {12, "HE"}, {13, "HW"},
{14, "HX"}, {15, "PN"}, {16, "SN"}, {17, "TS"}, {18, "VZ"}};
static inline const std::map<uint8_t, std::string> VSYSFieldTypes{
{2, "RT"}, {3, "BR"}, {4, "DR"}, {5, "FV"}, {6, "ID"},
{7, "MN"}, {8, "NN"}, {9, "RB"}, {10, "RG"}, {11, "SE"},
{12, "SG"}, {13, "SU"}, {14, "TM"}, {15, "TN"}, {16, "WN"}};
static inline const std::map<uint8_t, std::string> LXR0FieldTypes{
{2, "RT"}, {3, "LX"}, {4, "VZ"}};
static inline const std::map<uint8_t, std::string> VW10FieldTypes{
{2, "RT"}, {3, "DR"}, {4, "GD"}};
static inline const std::map<uint8_t, std::string> VR10FieldTypes{
{2, "RT"}, {3, "DC"}, {4, "DR"}, {5, "FL"}, {6, "WA"}};
static inline const std::map<std::string,
const std::map<uint8_t, std::string>>
populateMaps{{"VINI", VINIFieldTypes},
{"VSYS", VSYSFieldTypes},
{"LXR0", LXR0FieldTypes},
{"VWX10", VW10FieldTypes},
{"VR10", VR10FieldTypes}};
#endif
std::string typeToString(std::map<uint8_t, std::string> typeMap,
uint8_t type)
{
auto typeString = std::to_string(type);
try
{
return std::string(typeMap.at(type)) + "(" + typeString + ")";
}
catch (const std::out_of_range& e)
{
return typeString;
}
}
std::string fruFieldValuestring(const uint8_t* value, uint8_t length)
{
return std::string(reinterpret_cast<const char*>(value), length);
}
static std::string fruFieldParserU32(const uint8_t* value, uint8_t length)
{
assert(length == 4);
uint32_t v;
std::memcpy(&v, value, length);
return std::to_string(le32toh(v));
}
static std::string fruFieldParserTimestamp(const uint8_t*, uint8_t)
{
return std::string("TODO");
}
static std::string fruFieldIPZParser(const uint8_t* value, uint8_t length)
{
std::ostringstream tempStream;
for (int i = 0; i < int(length); ++i)
{
tempStream << "0x" << std::setfill('0') << std::setw(2) << std::hex
<< (unsigned)value[i] << " ";
}
return tempStream.str();
}
};
class GetFRURecordByOption : public CommandInterface
{
public:
~GetFRURecordByOption() = default;
GetFRURecordByOption() = delete;
GetFRURecordByOption(const GetFRURecordByOption&) = delete;
GetFRURecordByOption(GetFruRecordTableMetadata&&) = delete;
GetFRURecordByOption& operator=(const GetFRURecordByOption&) = delete;
GetFRURecordByOption& operator=(GetFRURecordByOption&&) = delete;
explicit GetFRURecordByOption(const char* type, const char* name,
CLI::App* app) :
CommandInterface(type, name, app)
{
app->add_option("-i, --identifier", recordSetIdentifier,
"Record Set Identifier\n"
"Possible values: {All record sets = 0, Specific "
"record set = 1 – 65535}")
->required();
app->add_option("-r, --record", recordType,
"Record Type\n"
"Possible values: {All record types = 0, Specific "
"record types = 1 – 255}")
->required();
app->add_option("-f, --field", fieldType,
"Field Type\n"
"Possible values: {All record field types = 0, "
"Specific field types = 1 – 15}")
->required();
}
std::pair<int, std::vector<uint8_t>> createRequestMsg() override
{
if (fieldType != 0 && recordType == 0)
{
throw std::invalid_argument("if field type is non-zero, the record "
"type shall also be non-zero");
}
if (recordType == 254 && (fieldType > 2 && fieldType < 254))
{
throw std::invalid_argument(
"GetFRURecordByOption is not supported for recordType : 254 "
"and fieldType > 2");
}
auto payloadLength = sizeof(pldm_get_fru_record_by_option_req);
std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) + payloadLength,
0);
auto reqMsg = reinterpret_cast<pldm_msg*>(requestMsg.data());
auto rc = encode_get_fru_record_by_option_req(
instanceId, 0 /* DataTransferHandle */, 0 /* FRUTableHandle */,
recordSetIdentifier, recordType, fieldType, PLDM_GET_FIRSTPART,
reqMsg, payloadLength);
return {rc, requestMsg};
}
void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
{
uint8_t cc;
uint32_t dataTransferHandle;
uint8_t transferFlag;
variable_field fruData;
auto rc = decode_get_fru_record_by_option_resp(
responsePtr, payloadLength, &cc, &dataTransferHandle, &transferFlag,
&fruData);
if (rc != PLDM_SUCCESS || cc != PLDM_SUCCESS)
{
std::cerr << "Response Message Error: "
<< "rc=" << rc << ",cc=" << (int)cc << std::endl;
return;
}
FRUTablePrint tablePrint(fruData.ptr, fruData.length);
tablePrint.print();
}
private:
uint16_t recordSetIdentifier;
uint8_t recordType;
uint8_t fieldType;
};
class GetFruRecordTable : public CommandInterface
{
public:
~GetFruRecordTable() = default;
GetFruRecordTable() = delete;
GetFruRecordTable(const GetFruRecordTable&) = delete;
GetFruRecordTable(GetFruRecordTable&&) = default;
GetFruRecordTable& operator=(const GetFruRecordTable&) = delete;
GetFruRecordTable& operator=(GetFruRecordTable&&) = delete;
using CommandInterface::CommandInterface;
std::pair<int, std::vector<uint8_t>> createRequestMsg() override
{
std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
PLDM_GET_FRU_RECORD_TABLE_REQ_BYTES);
auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
auto rc = encode_get_fru_record_table_req(
instanceId, 0, PLDM_GET_FIRSTPART, request,
requestMsg.size() - sizeof(pldm_msg_hdr));
return {rc, requestMsg};
}
void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
{
uint8_t cc = 0;
uint32_t next_data_transfer_handle = 0;
uint8_t transfer_flag = 0;
size_t fru_record_table_length = 0;
std::vector<uint8_t> fru_record_table_data(payloadLength);
auto rc = decode_get_fru_record_table_resp(
responsePtr, payloadLength, &cc, &next_data_transfer_handle,
&transfer_flag, fru_record_table_data.data(),
&fru_record_table_length);
if (rc != PLDM_SUCCESS || cc != PLDM_SUCCESS)
{
std::cerr << "Response Message Error: "
<< "rc=" << rc << ",cc=" << (int)cc << std::endl;
return;
}
FRUTablePrint tablePrint(fru_record_table_data.data(),
fru_record_table_length);
tablePrint.print();
}
};
void registerCommand(CLI::App& app)
{
auto fru = app.add_subcommand("fru", "FRU type command");
fru->require_subcommand(1);
auto getFruRecordTableMetadata = fru->add_subcommand(
"GetFruRecordTableMetadata", "get FRU record table metadata");
commands.push_back(std::make_unique<GetFruRecordTableMetadata>(
"fru", "GetFruRecordTableMetadata", getFruRecordTableMetadata));
auto getFRURecordByOption = fru->add_subcommand("GetFRURecordByOption",
"get FRU Record By Option");
commands.push_back(std::make_unique<GetFRURecordByOption>(
"fru", "GetFRURecordByOption", getFRURecordByOption));
auto getFruRecordTable = fru->add_subcommand("GetFruRecordTable",
"get FRU Record Table");
commands.push_back(std::make_unique<GetFruRecordTable>(
"fru", "GetFruRecordTable", getFruRecordTable));
}
} // namespace fru
} // namespace pldmtool