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, &currentString);
+                    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;