pldmtool: Implement GetBIOSTable for attr/attrValue Table
Implement GetBIOSTable for the attribute table and attribute
value table.
Implement an iterator for bios table, it may be used in
libpldmresponder, at least in unit tests. So it's placed
in the utils namespace.
Tested:
Tested on fp5280g2, with json files:
https://gist.github.com/wangzqbj/b24558331cb35d14fca3b555ef03e458
$ pldmtool bios GetBIOSTable -t 0
...
...
PLDM StringTable:
BIOSStringHandle : BIOSString
0 : CodeUpdatePolicy
1 : Concurrent
2 : Disruptive
3 : Led
4 : Model
5 : OUTLET
6 : Off
7 : On
8 : str_example3
$ pldmtool bios GetBIOSTable -t 1
...
...
PLDM AttributeTable:
AttributeHandle: 0, AttributeNameHandle: 0(CodeUpdatePolicy)
AttributeType: BIOSEnumerationReadOnly
NumberOfPossibleValues: 2
PossibleValueStringHandle[0] = 1(Concurrent)
PossibleValueStringHandle[1] = 2(Disruptive)
NumberOfDefaultValues: 1
DefaultValueStringHandleIndex[0] = 0, StringHandle = 1(Concurrent)
AttributeHandle: 1, AttributeNameHandle: 3(Led)
AttributeType: BIOSEnumeration
NumberOfPossibleValues: 2
PossibleValueStringHandle[0] = 6(Off)
PossibleValueStringHandle[1] = 7(On)
NumberOfDefaultValues: 1
DefaultValueStringHandleIndex[0] = 0, StringHandle = 6(Off)
AttributeHandle: 2, AttributeNameHandle: 5(OUTLET)
AttributeType: BIOSInteger
LowerBound: 0
UpperBound: 68002
ScalarIncrement: 1
DefaultValue:0
AttributeHandle: 3, AttributeNameHandle: 4(Model)
AttributeType: BIOSString
StringType: 0x01
MinimumStringLength: 1
MaximumStringLength: 100
DefaultStringLength: 8
DefaultString: FP5280G2
AttributeHandle: 4, AttributeNameHandle: 8(str_example3)
AttributeType: BIOSStringReadOnly
StringType: 0x00
MinimumStringLength: 1
MaximumStringLength: 100
DefaultStringLength: 2
DefaultString: ef
$ pldmtool bios GetBIOSTable -t 2
...
...
PLDM AttributeValueTable:
AttributeHandle: 0
AttributeType: BIOSEnumerationReadOnly
NumberOfCurrentValues: 1
CurrentValueStringHandleIndex[0] = 0, StringHandle = 1(Concurrent)
AttributeHandle: 1
AttributeType: BIOSEnumeration
NumberOfCurrentValues: 1
CurrentValueStringHandleIndex[0] = 0, StringHandle = 6(Off)
AttributeHandle: 2
AttributeType: BIOSInteger
CurrentValue: 0
AttributeHandle: 3
AttributeType: BIOSString
CurrentStringLength: 12
CurrentString: powersupply0
AttributeHandle: 4
AttributeType: BIOSStringReadOnly
CurrentStringLength: 2
CurrentString: ef
Signed-off-by: John Wang <wangzqbj@inspur.com>
Change-Id: Iaf79af8267fc0afc5c53704537dd7b6dfc36a6a7
diff --git a/bios_utils.hpp b/bios_utils.hpp
new file mode 100644
index 0000000..8f9f8a9
--- /dev/null
+++ b/bios_utils.hpp
@@ -0,0 +1,140 @@
+#pragma once
+
+#include <cstring>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+#include "libpldm/bios_table.h"
+
+namespace pldm
+{
+namespace bios
+{
+namespace utils
+{
+
+using Table = std::vector<uint8_t>;
+
+/** @class BIOSTableIter
+ * @brief Const Iterator of a BIOS Table
+ */
+template <pldm_bios_table_types tableType>
+class BIOSTableIter
+{
+ public:
+ /** @struct EndSentinel
+ * @brief Auxiliary struct to delimit a range
+ */
+ struct EndSentinel
+ {
+ };
+
+ /** @struct iterator
+ * @brief iterator owns the BIOS table
+ */
+ class iterator
+ {
+ public:
+ /** @brief Get entry type by specifying \p tableType
+ */
+ using T = typename std::conditional<
+ tableType == PLDM_BIOS_STRING_TABLE, pldm_bios_string_table_entry,
+ typename std::conditional<
+ tableType == PLDM_BIOS_ATTR_TABLE, pldm_bios_attr_table_entry,
+ typename std::conditional<tableType == PLDM_BIOS_ATTR_VAL_TABLE,
+ pldm_bios_attr_val_table_entry,
+ void>::type>::type>::type;
+ static_assert(!std::is_void<T>::value);
+
+ /** @brief Constructors iterator
+ *
+ * @param[in] data - Pointer to a table
+ * @param[in] length - The length of the table
+ */
+ explicit iterator(const void* data, size_t length) noexcept :
+ iter(pldm_bios_table_iter_create(data, length, tableType),
+ pldm_bios_table_iter_free)
+ {
+ }
+
+ /** @brief Get the entry pointed by the iterator
+ *
+ * @return Poiner to the entry
+ */
+ const T* operator*() const
+ {
+ return reinterpret_cast<const T*>(
+ pldm_bios_table_iter_value(iter.get()));
+ }
+
+ /** @brief Make the iterator point to the next entry
+ *
+ * @return The iterator itself
+ */
+ iterator& operator++()
+ {
+ pldm_bios_table_iter_next(iter.get());
+ return *this;
+ }
+
+ /** @brief Check if the iterator ends
+ *
+ * @return True if the iterator ends
+ */
+ bool operator==(const EndSentinel&) const
+ {
+ return pldm_bios_table_iter_is_end(iter.get());
+ }
+
+ /** @brief Check if the iterator ends
+ *
+ * @return False if the iterator ends
+ */
+ bool operator!=(const EndSentinel& endSentinel) const
+ {
+ return !operator==(endSentinel);
+ }
+
+ private:
+ std::unique_ptr<pldm_bios_table_iter,
+ decltype(&pldm_bios_table_iter_free)>
+ iter;
+ };
+
+ /** @brief Constructors BIOSTableIterator
+ *
+ * @param[in] data - Pointer to a table
+ * @param[in] length - The length of the table
+ */
+ BIOSTableIter(const void* data, size_t length) noexcept :
+ tableData(data), tableSize(length)
+ {
+ }
+
+ /** @brief Get the iterator to the beginning
+ *
+ * @return An iterator to the beginning
+ */
+ iterator begin()
+ {
+ return iterator(tableData, tableSize);
+ }
+
+ /** @brief Get the iterator to the end
+ *
+ * @return An iterator to the end
+ */
+ EndSentinel end()
+ {
+ return {};
+ }
+
+ private:
+ const void* tableData;
+ size_t tableSize;
+};
+
+} // namespace utils
+} // namespace bios
+} // namespace pldm
diff --git a/tool/pldm_bios_cmd.cpp b/tool/pldm_bios_cmd.cpp
index 1fb9853..13a8a4a 100644
--- a/tool/pldm_bios_cmd.cpp
+++ b/tool/pldm_bios_cmd.cpp
@@ -1,6 +1,11 @@
#include "pldm_bios_cmd.hpp"
+#include "bios_utils.hpp"
#include "pldm_cmd_helper.hpp"
+#include "utils.hpp"
+
+#include <map>
+#include <optional>
#include "libpldm/bios_table.h"
#include "libpldm/utils.h"
@@ -15,6 +20,7 @@
{
using namespace pldmtool::helper;
+using namespace pldm::bios::utils;
std::vector<std::unique_ptr<CommandInterface>> commands;
@@ -164,7 +170,7 @@
GetBIOSTable& operator=(const GetBIOSTable&) = delete;
GetBIOSTable& operator=(GetBIOSTable&&) = default;
- using CommandInterface::CommandInterface;
+ using Table = std::vector<uint8_t>;
explicit GetBIOSTable(const char* type, const char* name, CLI::App* app) :
CommandInterface(type, name, app)
@@ -177,94 +183,372 @@
std::pair<int, std::vector<uint8_t>> createRequestMsg() override
{
- uint32_t nextTransferHandle = 32;
+ return {PLDM_ERROR, {}};
+ }
+ void parseResponseMsg(pldm_msg*, size_t) override
+ {
+ }
+ std::optional<Table> getBIOSTable(pldm_bios_table_types tableType)
+ {
std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
PLDM_GET_BIOS_TABLE_REQ_BYTES);
auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
auto rc = encode_get_bios_table_req(
- PLDM_LOCAL_INSTANCE_ID, nextTransferHandle, PLDM_GET_FIRSTPART,
- pldmBIOSTableType, request);
- return {rc, requestMsg};
- }
+ PLDM_LOCAL_INSTANCE_ID, 0, PLDM_GET_FIRSTPART, tableType, request);
+ if (rc != PLDM_SUCCESS)
+ {
+ std::cerr << "Encode GetBIOSTable Error, tableType=," << tableType
+ << " ,rc=" << rc << std::endl;
+ return std::nullopt;
+ }
+ std::vector<uint8_t> responseMsg;
+ rc = pldmSendRecv(requestMsg, responseMsg);
+ if (rc != PLDM_SUCCESS)
+ {
+ std::cerr << "PLDM: Communication Error, rc =" << rc << std::endl;
+ return std::nullopt;
+ }
- void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
- {
uint8_t cc = 0, transferFlag = 0;
uint32_t nextTransferHandle = 0;
size_t bios_table_offset;
+ auto responsePtr =
+ reinterpret_cast<struct pldm_msg*>(responseMsg.data());
+ auto payloadLength = responseMsg.size() - sizeof(pldm_msg_hdr);
- auto rc = decode_get_bios_table_resp(responsePtr, payloadLength, &cc,
- &nextTransferHandle, &transferFlag,
- &bios_table_offset);
+ rc = decode_get_bios_table_resp(responsePtr, payloadLength, &cc,
+ &nextTransferHandle, &transferFlag,
+ &bios_table_offset);
if (rc != PLDM_SUCCESS || cc != PLDM_SUCCESS)
{
- std::cerr << "Response Message Error: "
- << "rc=" << rc << ",cc=" << (int)cc << std::endl;
- return;
+ std::cerr << "GetBIOSTable Response Error: tableType=" << tableType
+ << ", rc=" << rc << ", cc=" << (int)cc << std::endl;
+ return std::nullopt;
}
auto tableData =
reinterpret_cast<char*>((responsePtr->payload) + bios_table_offset);
- auto tableSize =
- payloadLength - sizeof(nextTransferHandle) - sizeof(transferFlag);
- printBIOSTable(tableData, tableSize, pldmBIOSTableType);
+ auto tableSize = payloadLength - sizeof(nextTransferHandle) -
+ sizeof(transferFlag) - sizeof(cc);
+ return std::make_optional<Table>(tableData, tableData + tableSize);
+ }
+
+ void exec() override
+ {
+
+ switch (pldmBIOSTableType)
+ {
+ case PLDM_BIOS_STRING_TABLE:
+ {
+ auto stringTable = getBIOSTable(PLDM_BIOS_STRING_TABLE);
+ decodeStringTable(stringTable);
+ break;
+ }
+ case PLDM_BIOS_ATTR_TABLE:
+ {
+ auto stringTable = getBIOSTable(PLDM_BIOS_STRING_TABLE);
+ auto attrTable = getBIOSTable(PLDM_BIOS_ATTR_TABLE);
+
+ decodeAttributeTable(attrTable, stringTable);
+ }
+ break;
+ case PLDM_BIOS_ATTR_VAL_TABLE:
+ {
+ auto stringTable = getBIOSTable(PLDM_BIOS_STRING_TABLE);
+ auto attrTable = getBIOSTable(PLDM_BIOS_ATTR_TABLE);
+ auto attrValTable = getBIOSTable(PLDM_BIOS_ATTR_VAL_TABLE);
+
+ decodeAttributeValueTable(attrValTable, attrTable, stringTable);
+ break;
+ }
+ }
}
private:
pldm_bios_table_types pldmBIOSTableType;
- void decodeStringTable(const void* tableData, size_t tableSize)
+ static inline const std::map<pldm_bios_attribute_type, const char*>
+ attrTypeMap = {
+ {PLDM_BIOS_ENUMERATION, "BIOSEnumeration"},
+ {PLDM_BIOS_ENUMERATION_READ_ONLY, "BIOSEnumerationReadOnly"},
+ {PLDM_BIOS_STRING, "BIOSString"},
+ {PLDM_BIOS_STRING_READ_ONLY, "BIOSStringReadOnly"},
+ {PLDM_BIOS_PASSWORD, "BIOSPassword"},
+ {PLDM_BIOS_PASSWORD_READ_ONLY, "BIOSPasswordReadOnly"},
+ {PLDM_BIOS_INTEGER, "BIOSInteger"},
+ {PLDM_BIOS_INTEGER_READ_ONLY, "BIOSIntegerReadOnly"},
+
+ };
+
+ std::string decodeStringFromStringEntry(
+ const pldm_bios_string_table_entry* stringEntry)
+ {
+ auto strLength =
+ pldm_bios_table_string_entry_decode_string_length(stringEntry);
+ std::vector<char> buffer(strLength + 1 /* sizeof '\0' */);
+ pldm_bios_table_string_entry_decode_string(stringEntry, buffer.data(),
+ buffer.size());
+
+ return std::string(buffer.data(), buffer.data() + strLength);
+ }
+
+ std::string displayStringHandle(uint16_t handle,
+ const std::optional<Table>& stringTable)
+ {
+ std::string displayString = std::to_string(handle);
+ if (!stringTable)
+ {
+ return displayString;
+ }
+ auto stringEntry = pldm_bios_table_string_find_by_handle(
+ stringTable->data(), stringTable->size(), handle);
+ if (stringEntry == nullptr)
+ {
+ return displayString;
+ }
+
+ return displayString + "(" + decodeStringFromStringEntry(stringEntry) +
+ ")";
+ }
+
+ std::string displayEnumValueByIndex(uint16_t attrHandle, uint8_t index,
+ const std::optional<Table>& attrTable,
+ const std::optional<Table>& stringTable)
+ {
+ std::string displayString;
+ if (!attrTable)
+ {
+ return displayString;
+ }
+
+ auto attrEntry = pldm_bios_table_attr_find_by_handle(
+ attrTable->data(), attrTable->size(), attrHandle);
+ if (attrEntry == nullptr)
+ {
+ return displayString;
+ }
+ auto pvNum = pldm_bios_table_attr_entry_enum_decode_pv_num(attrEntry);
+ std::vector<uint16_t> pvHandls(pvNum);
+ pldm_bios_table_attr_entry_enum_decode_pv_hdls(
+ attrEntry, pvHandls.data(), pvHandls.size());
+ return displayStringHandle(pvHandls[index], stringTable);
+ }
+
+ void decodeStringTable(const std::optional<Table>& stringTable)
{
std::cout << "Parsed Response Msg: " << std::endl;
- std::cout << "BIOSStringHandle : BIOSString" << std::endl;
- std::string strTableData;
- std::unique_ptr<pldm_bios_table_iter,
- decltype(&pldm_bios_table_iter_free)>
- iter(pldm_bios_table_iter_create(tableData, tableSize,
- PLDM_BIOS_STRING_TABLE),
- pldm_bios_table_iter_free);
- while (!pldm_bios_table_iter_is_end(iter.get()))
+ if (!stringTable)
{
- try
- {
- auto tableEntry =
- pldm_bios_table_iter_string_entry_value(iter.get());
- auto strLength =
- pldm_bios_table_string_entry_decode_string_length(
- tableEntry);
- strTableData.resize(strLength + 1);
- auto strHandle =
- pldm_bios_table_string_entry_decode_handle(tableEntry);
- pldm_bios_table_string_entry_decode_string(
- tableEntry, strTableData.data(), strTableData.size());
- std::cout << strHandle << " : " << strTableData << std::endl;
- }
- catch (const std::exception& e)
- {
- std::cerr
- << "handler fails when traversing BIOSStringTable, ERROR="
- << e.what() << "\n";
- }
- pldm_bios_table_iter_next(iter.get());
- }
- }
- void printBIOSTable(const void* tableData, size_t tableSize,
- enum pldm_bios_table_types type)
- {
- if (!tableSize)
- {
- std::cerr << "Found table size null." << std::endl;
+ std::cerr << "GetBIOSStringTable Error" << std::endl;
return;
}
- switch (type)
+ std::cout << "PLDM StringTable: " << std::endl;
+ std::cout << "BIOSStringHandle : BIOSString" << std::endl;
+
+ for (auto tableEntry : BIOSTableIter<PLDM_BIOS_STRING_TABLE>(
+ stringTable->data(), stringTable->size()))
{
- case PLDM_BIOS_STRING_TABLE:
- decodeStringTable(tableData, tableSize);
- break;
- default:
- break;
+ auto strHandle =
+ pldm_bios_table_string_entry_decode_handle(tableEntry);
+ auto strTableData = decodeStringFromStringEntry(tableEntry);
+ std::cout << strHandle << " : " << strTableData << std::endl;
+ }
+ }
+ void decodeAttributeTable(const std::optional<Table>& attrTable,
+ const std::optional<Table>& stringTable)
+ {
+ std::cout << "Parsed Response Msg: " << std::endl;
+ if (!stringTable)
+ {
+ std::cerr << "GetBIOSAttributeTable Error" << std::endl;
+ return;
+ }
+ std::cout << "PLDM AttributeTable: " << std::endl;
+ for (auto entry : BIOSTableIter<PLDM_BIOS_ATTR_TABLE>(
+ attrTable->data(), attrTable->size()))
+ {
+ auto attrHandle =
+ pldm_bios_table_attr_entry_decode_attribute_handle(entry);
+ auto attrNameHandle =
+ pldm_bios_table_attr_entry_decode_string_handle(entry);
+ auto attrType = static_cast<pldm_bios_attribute_type>(
+ pldm_bios_table_attr_entry_decode_attribute_type(entry));
+ std::cout << "AttributeHandle: " << attrHandle
+ << ", AttributeNameHandle: "
+ << displayStringHandle(attrNameHandle, stringTable)
+ << std::endl;
+ std::cout << "\tAttributeType: " << attrTypeMap.at(attrType)
+ << std::endl;
+ switch (attrType)
+ {
+ case PLDM_BIOS_ENUMERATION:
+ case PLDM_BIOS_ENUMERATION_READ_ONLY:
+ {
+ auto pvNum =
+ pldm_bios_table_attr_entry_enum_decode_pv_num(entry);
+ std::vector<uint16_t> pvHandls(pvNum);
+ pldm_bios_table_attr_entry_enum_decode_pv_hdls(
+ entry, pvHandls.data(), pvHandls.size());
+ auto defNum =
+ pldm_bios_table_attr_entry_enum_decode_def_num(entry);
+ std::vector<uint8_t> defIndices(defNum);
+ pldm_bios_table_attr_entry_enum_decode_def_indices(
+ entry, defIndices.data(), defIndices.size());
+ std::cout << "\tNumberOfPossibleValues: " << (int)pvNum
+ << std::endl;
+
+ for (size_t i = 0; i < pvHandls.size(); i++)
+ {
+ std::cout
+ << "\t\tPossibleValueStringHandle"
+ << "[" << i << "] = "
+ << displayStringHandle(pvHandls[i], stringTable)
+ << std::endl;
+ }
+ std::cout << "\tNumberOfDefaultValues: " << (int)defNum
+ << std::endl;
+ for (size_t i = 0; i < defIndices.size(); i++)
+ {
+ std::cout << "\t\tDefaultValueStringHandleIndex"
+ << "[" << i << "] = " << (int)defIndices[i]
+ << ", StringHandle = "
+ << displayStringHandle(
+ pvHandls[defIndices[i]], stringTable)
+ << std::endl;
+ }
+ break;
+ }
+ case PLDM_BIOS_INTEGER:
+ case PLDM_BIOS_INTEGER_READ_ONLY:
+ {
+ uint64_t lower, upper, def;
+ uint32_t scalar;
+ pldm_bios_table_attr_entry_integer_decode(
+ entry, &lower, &upper, &scalar, &def);
+ std::cout << "\tLowerBound: " << lower << std::endl
+ << "\tUpperBound: " << upper << std::endl
+ << "\tScalarIncrement: " << scalar << std::endl
+ << "\tDefaultValue: " << def << std::endl;
+ break;
+ }
+ case PLDM_BIOS_STRING:
+ case PLDM_BIOS_STRING_READ_ONLY:
+ {
+ auto strType =
+ pldm_bios_table_attr_entry_string_decode_string_type(
+ entry);
+ auto min =
+ pldm_bios_table_attr_entry_string_decode_min_length(
+ entry);
+ auto max =
+ pldm_bios_table_attr_entry_string_decode_max_length(
+ entry);
+ auto def =
+ pldm_bios_table_attr_entry_string_decode_def_string_length(
+ entry);
+ std::vector<char> defString(def + 1);
+ pldm_bios_table_attr_entry_string_decode_def_string(
+ entry, defString.data(), defString.size());
+ std::cout
+ << "\tStringType: 0x" << std::hex << std::setw(2)
+ << std::setfill('0') << (int)strType << std::dec
+ << std::setw(0) << std::endl
+ << "\tMinimumStringLength: " << (int)min << std::endl
+ << "\tMaximumStringLength: " << (int)max << std::endl
+ << "\tDefaultStringLength: " << (int)def << std::endl
+ << "\tDefaultString: " << defString.data() << std::endl;
+ break;
+ }
+ case PLDM_BIOS_PASSWORD:
+ case PLDM_BIOS_PASSWORD_READ_ONLY:
+ std::cout << "Password attribute: Not Supported"
+ << std::endl;
+ }
+ }
+ }
+ void decodeAttributeValueTable(const std::optional<Table>& attrValTable,
+ const std::optional<Table>& attrTable,
+ const std::optional<Table>& stringTable)
+ {
+ std::cout << "Parsed Response Msg: " << std::endl;
+ if (!attrValTable)
+ {
+ std::cerr << "GetBIOSAttributeValueTable Error" << std::endl;
+ return;
+ }
+ std::cout << "PLDM AttributeValueTable: " << std::endl;
+ for (auto tableEntry : BIOSTableIter<PLDM_BIOS_ATTR_VAL_TABLE>(
+ attrValTable->data(), attrValTable->size()))
+ {
+ auto attrHandle =
+ pldm_bios_table_attr_value_entry_decode_attribute_handle(
+ tableEntry);
+ auto attrType = static_cast<pldm_bios_attribute_type>(
+ pldm_bios_table_attr_value_entry_decode_attribute_type(
+ tableEntry));
+ std::cout << "AttributeHandle: " << attrHandle << std::endl;
+ std::cout << "\tAttributeType: " << attrTypeMap.at(attrType)
+ << std::endl;
+ switch (attrType)
+ {
+ case PLDM_BIOS_ENUMERATION:
+ case PLDM_BIOS_ENUMERATION_READ_ONLY:
+ {
+
+ auto count =
+ pldm_bios_table_attr_value_entry_enum_decode_number(
+ tableEntry);
+ std::vector<uint8_t> handles(count);
+ pldm_bios_table_attr_value_entry_enum_decode_handles(
+ tableEntry, handles.data(), handles.size());
+ std::cout << "\tNumberOfCurrentValues: " << (int)count
+ << std::endl;
+ for (size_t i = 0; i < handles.size(); i++)
+ {
+ std::cout
+ << "\tCurrentValueStringHandleIndex[" << i
+ << "] = " << (int)handles[i] << ", StringHandle = "
+ << displayEnumValueByIndex(attrHandle, handles[i],
+ attrTable, stringTable)
+ << std::endl;
+ }
+ break;
+ }
+ case PLDM_BIOS_INTEGER:
+ case PLDM_BIOS_INTEGER_READ_ONLY:
+ {
+ auto cv =
+ pldm_bios_table_attr_value_entry_integer_decode_cv(
+ tableEntry);
+ std::cout << "\tCurrentValue: " << cv << std::endl;
+ break;
+ }
+ case PLDM_BIOS_STRING:
+ case PLDM_BIOS_STRING_READ_ONLY:
+ {
+ auto stringLength =
+ pldm_bios_table_attr_value_entry_string_decode_length(
+ tableEntry);
+ variable_field currentString;
+ pldm_bios_table_attr_value_entry_string_decode_string(
+ tableEntry, ¤tString);
+ std::cout << "\tCurrentStringLength: " << stringLength
+ << std::endl
+ << "\tCurrentString: "
+ << std::string(reinterpret_cast<const char*>(
+ currentString.ptr),
+ currentString.length)
+ << std::endl;
+
+ break;
+ }
+ case PLDM_BIOS_PASSWORD:
+ case PLDM_BIOS_PASSWORD_READ_ONLY:
+ std::cout << "Password attribute: Not Supported"
+ << std::endl;
+ }
}
}
};
diff --git a/tool/pldm_cmd_helper.cpp b/tool/pldm_cmd_helper.cpp
index 4f3f210..1c03121 100644
--- a/tool/pldm_cmd_helper.cpp
+++ b/tool/pldm_cmd_helper.cpp
@@ -180,6 +180,23 @@
std::cout << "Encode request successfully" << std::endl;
+ std::vector<uint8_t> responseMsg;
+ rc = pldmSendRecv(requestMsg, responseMsg);
+
+ if (rc != PLDM_SUCCESS)
+ {
+ std::cerr << "pldmSendRecv: Failed to receive RC = " << rc << "\n";
+ return;
+ }
+
+ auto responsePtr = reinterpret_cast<struct pldm_msg*>(responseMsg.data());
+ parseResponseMsg(responsePtr, responseMsg.size() - sizeof(pldm_msg_hdr));
+}
+
+int CommandInterface::pldmSendRecv(std::vector<uint8_t>& requestMsg,
+ std::vector<uint8_t>& responseMsg)
+{
+
// Insert the PLDM message type and EID at the begining of the request msg.
requestMsg.insert(requestMsg.begin(), MCTP_MSG_TYPE_PLDM);
requestMsg.insert(requestMsg.begin(), PLDM_ENTITY_ID);
@@ -187,23 +204,20 @@
std::cout << "Request Message:" << std::endl;
printBuffer(requestMsg);
- std::vector<uint8_t> responseMsg;
- rc = mctpSockSendRecv(requestMsg, responseMsg);
+ auto rc = mctpSockSendRecv(requestMsg, responseMsg);
if (rc != PLDM_SUCCESS)
{
- std::cerr << "Failed to receive from socket: RC = " << rc << "\n";
- return;
+ std::cerr << "Failed to receive from mctpSocket: RC = " << rc << "\n";
+ return rc;
}
std::cout << "Response Message:" << std::endl;
printBuffer(responseMsg);
- auto responsePtr = reinterpret_cast<struct pldm_msg*>(
- responseMsg.data() + 2 /*skip the mctp header*/);
- parseResponseMsg(responsePtr, responseMsg.size() -
- 2 /*skip the mctp header*/ -
- sizeof(pldm_msg_hdr));
+ responseMsg.erase(responseMsg.begin(),
+ responseMsg.begin() + 2 /* skip the mctp header */);
+ return PLDM_SUCCESS;
}
} // namespace helper
diff --git a/tool/pldm_cmd_helper.hpp b/tool/pldm_cmd_helper.hpp
index 2c736ec..8060751 100644
--- a/tool/pldm_cmd_helper.hpp
+++ b/tool/pldm_cmd_helper.hpp
@@ -66,7 +66,10 @@
virtual void parseResponseMsg(struct pldm_msg* responsePtr,
size_t payloadLength) = 0;
- void exec();
+ virtual void exec();
+
+ int pldmSendRecv(std::vector<uint8_t>& requestMsg,
+ std::vector<uint8_t>& responseMsg);
private:
const std::string pldmType;