diff --git a/libpldm/base.c b/libpldm/base.c
index 1c1809e..36df1b0 100644
--- a/libpldm/base.c
+++ b/libpldm/base.c
@@ -126,7 +126,7 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_get_commands_req(const uint8_t *msg, size_t payload_length,
+int decode_get_commands_req(const struct pldm_msg *msg, size_t payload_length,
 			    uint8_t *type, ver32_t *version)
 {
 	if (msg == NULL || type == NULL || version == NULL) {
@@ -138,7 +138,7 @@
 	}
 
 	struct pldm_get_commands_req *request =
-	    (struct pldm_get_commands_req *)msg;
+	    (struct pldm_get_commands_req *)msg->payload;
 	*type = request->type;
 	*version = request->version;
 	return PLDM_SUCCESS;
@@ -172,7 +172,7 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_get_types_resp(const uint8_t *msg, size_t payload_length,
+int decode_get_types_resp(const struct pldm_msg *msg, size_t payload_length,
 			  uint8_t *completion_code, bitfield8_t *types)
 {
 	if (msg == NULL || types == NULL || completion_code == NULL) {
@@ -184,7 +184,7 @@
 	}
 
 	struct pldm_get_types_resp *response =
-	    (struct pldm_get_types_resp *)msg;
+	    (struct pldm_get_types_resp *)msg->payload;
 	*completion_code = response->completion_code;
 	if (PLDM_SUCCESS != *completion_code) {
 		return PLDM_SUCCESS;
@@ -195,7 +195,7 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_get_commands_resp(const uint8_t *msg, size_t payload_length,
+int decode_get_commands_resp(const struct pldm_msg *msg, size_t payload_length,
 			     uint8_t *completion_code, bitfield8_t *commands)
 {
 	if (msg == NULL || commands == NULL || completion_code == NULL) {
@@ -207,7 +207,7 @@
 	}
 
 	struct pldm_get_commands_resp *response =
-	    (struct pldm_get_commands_resp *)msg;
+	    (struct pldm_get_commands_resp *)msg->payload;
 	*completion_code = response->completion_code;
 	if (PLDM_SUCCESS != *completion_code) {
 		return PLDM_SUCCESS;
@@ -278,7 +278,7 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_get_version_req(const uint8_t *msg, size_t payload_length,
+int decode_get_version_req(const struct pldm_msg *msg, size_t payload_length,
 			   uint32_t *transfer_handle, uint8_t *transfer_opflag,
 			   uint8_t *type)
 {
@@ -288,14 +288,14 @@
 	}
 
 	struct pldm_get_version_req *request =
-	    (struct pldm_get_version_req *)msg;
+	    (struct pldm_get_version_req *)msg->payload;
 	*transfer_handle = le32toh(request->transfer_handle);
 	*transfer_opflag = request->transfer_opflag;
 	*type = request->type;
 	return PLDM_SUCCESS;
 }
 
-int decode_get_version_resp(const uint8_t *msg, size_t payload_length,
+int decode_get_version_resp(const struct pldm_msg *msg, size_t payload_length,
 			    uint8_t *completion_code,
 			    uint32_t *next_transfer_handle,
 			    uint8_t *transfer_flag, ver32_t *version)
@@ -310,7 +310,7 @@
 	}
 
 	struct pldm_get_version_resp *response =
-	    (struct pldm_get_version_resp *)msg;
+	    (struct pldm_get_version_resp *)msg->payload;
 	*completion_code = response->completion_code;
 	if (PLDM_SUCCESS != *completion_code) {
 		return PLDM_SUCCESS;
diff --git a/libpldm/base.h b/libpldm/base.h
index 6a044ad..f15ca7e 100644
--- a/libpldm/base.h
+++ b/libpldm/base.h
@@ -221,14 +221,14 @@
 
 /** @brief Decode a GetPLDMTypes response message
  *
- *  @param[in] msg - Response message payload
+ *  @param[in] msg - Response message
  *  @param[in] payload_length - Length of response message payload
  *  @param[out] completion_code - Pointer to response msg's PLDM completion code
  *  @param[out] types - pointer to array bitfield8_t[8] containing supported
  *              types (MAX_TYPES/8) = 8), as per DSP0240
  *  @return pldm_completion_codes
  */
-int decode_get_types_resp(const uint8_t *msg, size_t payload_length,
+int decode_get_types_resp(const struct pldm_msg *msg, size_t payload_length,
 			  uint8_t *completion_code, bitfield8_t *types);
 
 /* GetPLDMCommands */
@@ -248,14 +248,14 @@
 
 /** @brief Decode a GetPLDMCommands response message
  *
- *  @param[in] msg - Response message payload
+ *  @param[in] msg - Response message
  *  @param[in] payload_length - Length of reponse message payload
  *  @param[out] completion_code - Pointer to response msg's PLDM completion code
  *  @param[in] commands - pointer to array bitfield8_t[32] containing supported
  *             commands (PLDM_MAX_CMDS_PER_TYPE/8) = 32), as per DSP0240
  *  @return pldm_completion_codes
  */
-int decode_get_commands_resp(const uint8_t *msg, size_t payload_length,
+int decode_get_commands_resp(const struct pldm_msg *msg, size_t payload_length,
 			     uint8_t *completion_code, bitfield8_t *commands);
 
 /* GetPLDMVersion */
@@ -280,14 +280,14 @@
 
 /** @brief Decode a GetPLDMVersion response message
  *
- *  @param[in] msg - Response message payload
+ *  @param[in] msg - Response message
  *  @param[in] payload_length - Length of reponse message payload
  *  @param[out] completion_code - Pointer to response msg's PLDM completion code
  *  @param[out] next_transfer_handle - the next handle for the next part of data
  *  @param[out] transfer_flag - flag to indicate the part of data
  *  @return pldm_completion_codes
  */
-int decode_get_version_resp(const uint8_t *msg, size_t payload_length,
+int decode_get_version_resp(const struct pldm_msg *msg, size_t payload_length,
 			    uint8_t *completion_code,
 			    uint32_t *next_transfer_handle,
 			    uint8_t *transfer_flag, ver32_t *version);
@@ -320,7 +320,7 @@
  *  @param[out] version - Version for PLDM Type
  *  @return pldm_completion_codes
  */
-int decode_get_commands_req(const uint8_t *msg, size_t payload_length,
+int decode_get_commands_req(const struct pldm_msg *msg, size_t payload_length,
 			    uint8_t *type, ver32_t *version);
 
 /** @brief Create a PLDM response message for GetPLDMCommands
@@ -367,7 +367,7 @@
  *  @param[out] type - PLDM type for which version is requested
  *  @return pldm_completion_codes
  */
-int decode_get_version_req(const uint8_t *msg, size_t payload_length,
+int decode_get_version_req(const struct pldm_msg *msg, size_t payload_length,
 			   uint32_t *transfer_handle, uint8_t *transfer_opflag,
 			   uint8_t *type);
 
diff --git a/libpldm/bios.c b/libpldm/bios.c
index 358fb38..9664318 100644
--- a/libpldm/bios.c
+++ b/libpldm/bios.c
@@ -55,7 +55,7 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_get_date_time_resp(const uint8_t *msg, size_t payload_length,
+int decode_get_date_time_resp(const struct pldm_msg *msg, size_t payload_length,
 			      uint8_t *completion_code, uint8_t *seconds,
 			      uint8_t *minutes, uint8_t *hours, uint8_t *day,
 			      uint8_t *month, uint16_t *year)
@@ -71,7 +71,7 @@
 	}
 
 	struct pldm_get_date_time_resp *response =
-	    (struct pldm_get_date_time_resp *)msg;
+	    (struct pldm_get_date_time_resp *)msg->payload;
 	*completion_code = response->completion_code;
 
 	if (PLDM_SUCCESS != *completion_code) {
diff --git a/libpldm/bios.h b/libpldm/bios.h
index cd35651..6f9e42b 100644
--- a/libpldm/bios.h
+++ b/libpldm/bios.h
@@ -47,7 +47,7 @@
 
 /** @brief Decode a GetDateTime response message
  *
- *  @param[in] msg - Response message payload
+ *  @param[in] msg - Response message
  *  @param[in] payload_length - Length of response message payload
  *  @param[out] completion_code - Pointer to response msg's PLDM completion code
  *  @param[out] seconds - Seconds in BCD format
@@ -58,7 +58,7 @@
  *  @param[out] year - year in BCD format
  *  @return pldm_completion_codes
  */
-int decode_get_date_time_resp(const uint8_t *msg, size_t payload_length,
+int decode_get_date_time_resp(const struct pldm_msg *msg, size_t payload_length,
 			      uint8_t *completion_code, uint8_t *seconds,
 			      uint8_t *minutes, uint8_t *hours, uint8_t *day,
 			      uint8_t *month, uint16_t *year);
diff --git a/libpldm/platform.c b/libpldm/platform.c
index d0929d9..f9c8351 100644
--- a/libpldm/platform.c
+++ b/libpldm/platform.c
@@ -55,7 +55,7 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_set_state_effecter_states_resp(const uint8_t *msg,
+int decode_set_state_effecter_states_resp(const struct pldm_msg *msg,
 					  size_t payload_length,
 					  uint8_t *completion_code)
 {
@@ -67,12 +67,12 @@
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
-	*completion_code = msg[0];
+	*completion_code = msg->payload[0];
 
 	return PLDM_SUCCESS;
 }
 
-int decode_set_state_effecter_states_req(const uint8_t *msg,
+int decode_set_state_effecter_states_req(const struct pldm_msg *msg,
 					 size_t payload_length,
 					 uint16_t *effecter_id,
 					 uint8_t *comp_effecter_count,
@@ -88,7 +88,7 @@
 	}
 
 	struct pldm_set_state_effecter_states_req *request =
-	    (struct pldm_set_state_effecter_states_req *)msg;
+	    (struct pldm_set_state_effecter_states_req *)msg->payload;
 
 	*effecter_id = le16toh(request->effecter_id);
 	*comp_effecter_count = request->comp_effecter_count;
diff --git a/libpldm/platform.h b/libpldm/platform.h
index 7d25eb3..d29dc8a 100644
--- a/libpldm/platform.h
+++ b/libpldm/platform.h
@@ -117,7 +117,7 @@
 
 /** @brief Decode SetStateEffecterStates request data
  *
- *  @param[in] msg - Request message payload
+ *  @param[in] msg - Request message
  *  @param[in] payload_length - Length of request message payload
  *  @param[out] effecter_id - used to identify and access the effecter
  *  @param[out] comp_effecter_count - number of individual sets of effecter
@@ -133,7 +133,7 @@
  *  @return pldm_completion_codes
  */
 
-int decode_set_state_effecter_states_req(const uint8_t *msg,
+int decode_set_state_effecter_states_req(const struct pldm_msg *msg,
 					 size_t payload_length,
 					 uint16_t *effecter_id,
 					 uint8_t *comp_effecter_count,
@@ -166,12 +166,12 @@
 					 struct pldm_msg *msg);
 
 /** @brief Decode SetStateEffecterStates response data
- *  @param[in] msg - Request message payload
+ *  @param[in] msg - Request message
  *  @param[in] payload_length - Length of response message payload
  *  @param[out] completion_code - PLDM completion code
  *  @return pldm_completion_codes
  */
-int decode_set_state_effecter_states_resp(const uint8_t *msg,
+int decode_set_state_effecter_states_resp(const struct pldm_msg *msg,
 					  size_t payload_length,
 					  uint8_t *completion_code);
 #ifdef __cplusplus
diff --git a/libpldmresponder/base.cpp b/libpldmresponder/base.cpp
index 43bcc12..fc4ddf6 100644
--- a/libpldmresponder/base.cpp
+++ b/libpldmresponder/base.cpp
@@ -73,8 +73,7 @@
     Response response(sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_RESP_BYTES, 0);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    auto rc = decode_get_commands_req(request->payload, payloadLength, &type,
-                                      &version);
+    auto rc = decode_get_commands_req(request, payloadLength, &type, &version);
 
     if (rc != PLDM_SUCCESS)
     {
@@ -116,8 +115,8 @@
     Response response(sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_RESP_BYTES, 0);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    uint8_t rc = decode_get_version_req(request->payload, payloadLength,
-                                        &transferHandle, &transferFlag, &type);
+    uint8_t rc = decode_get_version_req(request, payloadLength, &transferHandle,
+                                        &transferFlag, &type);
 
     if (rc != PLDM_SUCCESS)
     {
diff --git a/oem/ibm/libpldm/file_io.c b/oem/ibm/libpldm/file_io.c
index fd96f1c..7806ae6 100644
--- a/oem/ibm/libpldm/file_io.c
+++ b/oem/ibm/libpldm/file_io.c
@@ -2,7 +2,7 @@
 #include <endian.h>
 #include <string.h>
 
-int decode_rw_file_memory_req(const uint8_t *msg, size_t payload_length,
+int decode_rw_file_memory_req(const struct pldm_msg *msg, size_t payload_length,
 			      uint32_t *file_handle, uint32_t *offset,
 			      uint32_t *length, uint64_t *address)
 {
@@ -16,7 +16,7 @@
 	}
 
 	struct pldm_read_write_file_memory_req *request =
-	    (struct pldm_read_write_file_memory_req *)msg;
+	    (struct pldm_read_write_file_memory_req *)msg->payload;
 
 	*file_handle = le32toh(request->file_handle);
 	*offset = le32toh(request->offset);
@@ -81,8 +81,9 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_rw_file_memory_resp(const uint8_t *msg, size_t payload_length,
-			       uint8_t *completion_code, uint32_t *length)
+int decode_rw_file_memory_resp(const struct pldm_msg *msg,
+			       size_t payload_length, uint8_t *completion_code,
+			       uint32_t *length)
 {
 	if (msg == NULL || length == NULL || completion_code == NULL) {
 		return PLDM_ERROR_INVALID_DATA;
@@ -93,7 +94,7 @@
 	}
 
 	struct pldm_read_write_file_memory_resp *response =
-	    (struct pldm_read_write_file_memory_resp *)msg;
+	    (struct pldm_read_write_file_memory_resp *)msg->payload;
 	*completion_code = response->completion_code;
 	if (*completion_code == PLDM_SUCCESS) {
 		*length = le32toh(response->length);
@@ -102,7 +103,7 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_get_file_table_req(const uint8_t *msg, size_t payload_length,
+int decode_get_file_table_req(const struct pldm_msg *msg, size_t payload_length,
 			      uint32_t *transfer_handle,
 			      uint8_t *transfer_opflag, uint8_t *table_type)
 {
@@ -116,7 +117,7 @@
 	}
 
 	struct pldm_get_file_table_req *request =
-	    (struct pldm_get_file_table_req *)msg;
+	    (struct pldm_get_file_table_req *)msg->payload;
 
 	*transfer_handle = le32toh(request->transfer_handle);
 	*transfer_opflag = request->operation_flag;
diff --git a/oem/ibm/libpldm/file_io.h b/oem/ibm/libpldm/file_io.h
index 64f203c..b3a0f73 100644
--- a/oem/ibm/libpldm/file_io.h
+++ b/oem/ibm/libpldm/file_io.h
@@ -66,7 +66,7 @@
 /** @brief Decode ReadFileIntoMemory and WriteFileFromMemory commands request
  *         data
  *
- *  @param[in] msg - Pointer to PLDM request message payload
+ *  @param[in] msg - Pointer to PLDM request message
  *  @param[in] payload_length - Length of request payload
  *  @param[out] file_handle - A handle to the file
  *  @param[out] offset - Offset to the file at which the read should begin
@@ -75,7 +75,7 @@
  *                        written to
  *  @return pldm_completion_codes
  */
-int decode_rw_file_memory_req(const uint8_t *msg, size_t payload_length,
+int decode_rw_file_memory_req(const struct pldm_msg *msg, size_t payload_length,
 			      uint32_t *file_handle, uint32_t *offset,
 			      uint32_t *length, uint64_t *address);
 
@@ -116,14 +116,15 @@
 /** @brief Decode ReadFileIntoMemory and WriteFileFromMemory
  *         commands response data
  *
- *  @param[in] msg - pointer to PLDM response message payload
+ *  @param[in] msg - pointer to PLDM response message
  *  @param[in] payload_length - Length of response payload
  *  @param[out] completion_code - PLDM completion code
  *  @param[out] length - Number of bytes to be read/written
  *  @return pldm_completion_codes
  */
-int decode_rw_file_memory_resp(const uint8_t *msg, size_t payload_length,
-			       uint8_t *completion_code, uint32_t *length);
+int decode_rw_file_memory_resp(const struct pldm_msg *msg,
+			       size_t payload_length, uint8_t *completion_code,
+			       uint32_t *length);
 
 /** @struct pldm_get_file_table_req
  *
@@ -148,14 +149,14 @@
 
 /** @brief Decode GetFileTable command request data
  *
- *  @param[in] msg - Pointer to PLDM request message payload
+ *  @param[in] msg - Pointer to PLDM request message
  *  @param[in] payload_length - Length of request payload
  *  @param[out] trasnfer_handle - the handle of data
  *  @param[out] transfer_opflag - Transfer operation flag
  *  @param[out] table_type - the type of file table
  *  @return pldm_completion_codes
  */
-int decode_get_file_table_req(const uint8_t *msg, size_t payload_length,
+int decode_get_file_table_req(const struct pldm_msg *msg, size_t payload_length,
 			      uint32_t *transfer_handle,
 			      uint8_t *transfer_opflag, uint8_t *table_type);
 
diff --git a/oem/ibm/libpldmresponder/file_io.cpp b/oem/ibm/libpldmresponder/file_io.cpp
index 6fa9f48..a3a81b4 100644
--- a/oem/ibm/libpldmresponder/file_io.cpp
+++ b/oem/ibm/libpldmresponder/file_io.cpp
@@ -172,8 +172,8 @@
         return response;
     }
 
-    decode_rw_file_memory_req(request->payload, payloadLength, &fileHandle,
-                              &offset, &length, &address);
+    decode_rw_file_memory_req(request, payloadLength, &fileHandle, &offset,
+                              &length, &address);
 
     using namespace pldm::filetable;
     auto& table = buildFileTable(FILE_TABLE_JSON);
@@ -253,8 +253,8 @@
         return response;
     }
 
-    decode_rw_file_memory_req(request->payload, payloadLength, &fileHandle,
-                              &offset, &length, &address);
+    decode_rw_file_memory_req(request, payloadLength, &fileHandle, &offset,
+                              &length, &address);
 
     if (length % dma::minSize)
     {
@@ -329,9 +329,8 @@
         return response;
     }
 
-    auto rc =
-        decode_get_file_table_req(request->payload, payloadLength,
-                                  &transferHandle, &transferFlag, &tableType);
+    auto rc = decode_get_file_table_req(request, payloadLength, &transferHandle,
+                                        &transferFlag, &tableType);
     if (rc)
     {
         encode_get_file_table_resp(request->hdr.instance_id, rc, 0, 0, nullptr,
diff --git a/oem/ibm/test/libpldm_fileio_test.cpp b/oem/ibm/test/libpldm_fileio_test.cpp
index 085d105..de766b1 100644
--- a/oem/ibm/test/libpldm_fileio_test.cpp
+++ b/oem/ibm/test/libpldm_fileio_test.cpp
@@ -7,9 +7,11 @@
 
 #include <gtest/gtest.h>
 
+constexpr auto hdrSize = sizeof(pldm_msg_hdr);
+
 TEST(ReadWriteFileMemory, testGoodDecodeRequest)
 {
-    std::array<uint8_t, PLDM_RW_FILE_MEM_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, PLDM_RW_FILE_MEM_REQ_BYTES + hdrSize> requestMsg{};
 
     // Random value for fileHandle, offset, length, address
     uint32_t fileHandle = 0x12345678;
@@ -17,12 +19,13 @@
     uint32_t length = 0x13245768;
     uint64_t address = 0x124356879ACBDE0F;
 
-    memcpy(requestMsg.data(), &fileHandle, sizeof(fileHandle));
-    memcpy(requestMsg.data() + sizeof(fileHandle), &offset, sizeof(offset));
-    memcpy(requestMsg.data() + sizeof(fileHandle) + sizeof(offset), &length,
-           sizeof(length));
+    memcpy(requestMsg.data() + hdrSize, &fileHandle, sizeof(fileHandle));
+    memcpy(requestMsg.data() + sizeof(fileHandle) + hdrSize, &offset,
+           sizeof(offset));
+    memcpy(requestMsg.data() + sizeof(fileHandle) + sizeof(offset) + hdrSize,
+           &length, sizeof(length));
     memcpy(requestMsg.data() + sizeof(fileHandle) + sizeof(offset) +
-               sizeof(length),
+               sizeof(length) + hdrSize,
            &address, sizeof(address));
 
     uint32_t retFileHandle = 0;
@@ -30,8 +33,10 @@
     uint32_t retLength = 0;
     uint64_t retAddress = 0;
 
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
     // Invoke decode the read file memory request
-    auto rc = decode_rw_file_memory_req(requestMsg.data(), requestMsg.size(),
+    auto rc = decode_rw_file_memory_req(request, requestMsg.size() - hdrSize,
                                         &retFileHandle, &retOffset, &retLength,
                                         &retAddress);
 
@@ -56,14 +61,16 @@
 
     std::array<uint8_t, PLDM_RW_FILE_MEM_REQ_BYTES> requestMsg{};
 
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
     // Address is NULL
-    rc = decode_rw_file_memory_req(requestMsg.data(), requestMsg.size(),
+    rc = decode_rw_file_memory_req(request, requestMsg.size() - hdrSize,
                                    &fileHandle, &offset, &length, NULL);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
     // Payload length is invalid
-    rc = decode_rw_file_memory_req(requestMsg.data(), 0, &fileHandle, &offset,
-                                   &length, &address);
+    rc = decode_rw_file_memory_req(request, 0, &fileHandle, &offset, &length,
+                                   &address);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
 }
 
@@ -133,20 +140,23 @@
 
 TEST(ReadWriteFileIntoMemory, testGoodDecodeResponse)
 {
-    std::array<uint8_t, PLDM_RW_FILE_MEM_RESP_BYTES> responseMsg{};
+    std::array<uint8_t, PLDM_RW_FILE_MEM_RESP_BYTES + hdrSize> responseMsg{};
     // Random value for length
     uint32_t length = 0xFF00EE12;
     uint8_t completionCode = 0;
 
-    memcpy(responseMsg.data(), &completionCode, sizeof(completionCode));
-    memcpy(responseMsg.data() + sizeof(completionCode), &length,
+    memcpy(responseMsg.data() + hdrSize, &completionCode,
+           sizeof(completionCode));
+    memcpy(responseMsg.data() + sizeof(completionCode) + hdrSize, &length,
            sizeof(length));
 
     uint8_t retCompletionCode = 0;
     uint32_t retLength = 0;
 
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
     // Invoke decode the read file memory response
-    auto rc = decode_rw_file_memory_resp(responseMsg.data(), responseMsg.size(),
+    auto rc = decode_rw_file_memory_resp(response, responseMsg.size() - hdrSize,
                                          &retCompletionCode, &retLength);
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completionCode, retCompletionCode);
@@ -164,9 +174,10 @@
 
     std::array<uint8_t, PLDM_RW_FILE_MEM_RESP_BYTES> responseMsg{};
 
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
     // Payload length is invalid
-    rc = decode_rw_file_memory_resp(responseMsg.data(), 0, &completionCode,
-                                    &length);
+    rc = decode_rw_file_memory_resp(response, 0, &completionCode, &length);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
 }
 
@@ -219,25 +230,29 @@
 
 TEST(GetFileTable, GoodDecodeRequest)
 {
-    std::array<uint8_t, PLDM_GET_FILE_TABLE_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, PLDM_GET_FILE_TABLE_REQ_BYTES + hdrSize> requestMsg{};
 
     // Random value for DataTransferHandle, TransferOperationFlag, TableType
     uint32_t transferHandle = 0x12345678;
     uint8_t transferOpFlag = 1;
     uint8_t tableType = 1;
 
-    memcpy(requestMsg.data(), &transferHandle, sizeof(transferHandle));
-    memcpy(requestMsg.data() + sizeof(transferHandle), &transferOpFlag,
-           sizeof(transferOpFlag));
-    memcpy(requestMsg.data() + sizeof(transferHandle) + sizeof(transferOpFlag),
+    memcpy(requestMsg.data() + hdrSize, &transferHandle,
+           sizeof(transferHandle));
+    memcpy(requestMsg.data() + sizeof(transferHandle) + hdrSize,
+           &transferOpFlag, sizeof(transferOpFlag));
+    memcpy(requestMsg.data() + sizeof(transferHandle) + sizeof(transferOpFlag) +
+               hdrSize,
            &tableType, sizeof(tableType));
 
     uint32_t retTransferHandle = 0;
     uint8_t retTransferOpFlag = 0;
     uint8_t retTableType = 0;
 
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
     // Invoke decode get file table request
-    auto rc = decode_get_file_table_req(requestMsg.data(), requestMsg.size(),
+    auto rc = decode_get_file_table_req(request, requestMsg.size() - hdrSize,
                                         &retTransferHandle, &retTransferOpFlag,
                                         &retTableType);
 
@@ -260,14 +275,16 @@
 
     std::array<uint8_t, PLDM_GET_FILE_TABLE_REQ_BYTES> requestMsg{};
 
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
     // TableType is NULL
-    rc = decode_get_file_table_req(requestMsg.data(), requestMsg.size(),
+    rc = decode_get_file_table_req(request, requestMsg.size() - hdrSize,
                                    &transferHandle, &transferOpFlag, nullptr);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
     // Payload length is invalid
-    rc = decode_get_file_table_req(requestMsg.data(), 0, &transferHandle,
-                                   &transferOpFlag, &tableType);
+    rc = decode_get_file_table_req(request, 0, &transferHandle, &transferOpFlag,
+                                   &tableType);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
 }
 
diff --git a/test/libpldm_base_test.cpp b/test/libpldm_base_test.cpp
index faa4d90..f17bccb 100644
--- a/test/libpldm_base_test.cpp
+++ b/test/libpldm_base_test.cpp
@@ -6,6 +6,8 @@
 
 #include <gtest/gtest.h>
 
+constexpr auto hdrSize = sizeof(pldm_msg_hdr);
+
 TEST(PackPLDMMessage, BadPathTest)
 {
     struct pldm_header_info hdr;
@@ -208,12 +210,16 @@
     ver32_t version{0xFF, 0xFF, 0xFF, 0xFF};
     uint8_t pldmTypeOut{};
     ver32_t versionOut{0xFF, 0xFF, 0xFF, 0xFF};
-    std::array<uint8_t, PLDM_GET_COMMANDS_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, hdrSize + PLDM_GET_COMMANDS_REQ_BYTES> requestMsg{};
 
-    memcpy(requestMsg.data(), &pldmType, sizeof(pldmType));
-    memcpy(requestMsg.data() + sizeof(pldmType), &version, sizeof(version));
-    auto rc = decode_get_commands_req(requestMsg.data(), requestMsg.size(),
+    memcpy(requestMsg.data() + hdrSize, &pldmType, sizeof(pldmType));
+    memcpy(requestMsg.data() + sizeof(pldmType) + hdrSize, &version,
+           sizeof(version));
+
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+    auto rc = decode_get_commands_req(request, requestMsg.size() - hdrSize,
                                       &pldmTypeOut, &versionOut);
+
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(pldmTypeOut, pldmType);
     ASSERT_EQ(0, memcmp(&versionOut, &version, sizeof(version)));
@@ -265,40 +271,44 @@
 
 TEST(GetPLDMTypes, testDecodeResponse)
 {
-    std::array<uint8_t, PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
-    responseMsg[1] = 1;
-    responseMsg[2] = 2;
-    responseMsg[3] = 3;
+    std::array<uint8_t, hdrSize + PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
+    responseMsg[1 + hdrSize] = 1;
+    responseMsg[2 + hdrSize] = 2;
+    responseMsg[3 + hdrSize] = 3;
     std::array<bitfield8_t, PLDM_MAX_TYPES / 8> outTypes{};
     uint8_t completion_code;
 
-    auto rc = decode_get_types_resp(responseMsg.data(), responseMsg.size(),
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+    auto rc = decode_get_types_resp(response, responseMsg.size() - hdrSize,
                                     &completion_code, outTypes.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(responseMsg[1], outTypes[0].byte);
-    ASSERT_EQ(responseMsg[2], outTypes[1].byte);
-    ASSERT_EQ(responseMsg[3], outTypes[2].byte);
+    ASSERT_EQ(responseMsg[1 + hdrSize], outTypes[0].byte);
+    ASSERT_EQ(responseMsg[2 + hdrSize], outTypes[1].byte);
+    ASSERT_EQ(responseMsg[3 + hdrSize], outTypes[2].byte);
 }
 
 TEST(GetPLDMCommands, testDecodeResponse)
 {
-    std::array<uint8_t, PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
-    responseMsg[1] = 1;
-    responseMsg[2] = 2;
-    responseMsg[3] = 3;
+    std::array<uint8_t, hdrSize + PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
+    responseMsg[1 + hdrSize] = 1;
+    responseMsg[2 + hdrSize] = 2;
+    responseMsg[3 + hdrSize] = 3;
     std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> outTypes{};
     uint8_t completion_code;
 
-    auto rc = decode_get_commands_resp(responseMsg.data(), responseMsg.size(),
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+    auto rc = decode_get_commands_resp(response, responseMsg.size() - hdrSize,
                                        &completion_code, outTypes.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(responseMsg[1], outTypes[0].byte);
-    ASSERT_EQ(responseMsg[2], outTypes[1].byte);
-    ASSERT_EQ(responseMsg[3], outTypes[2].byte);
+    ASSERT_EQ(responseMsg[1 + hdrSize], outTypes[0].byte);
+    ASSERT_EQ(responseMsg[2 + hdrSize], outTypes[1].byte);
+    ASSERT_EQ(responseMsg[3 + hdrSize], outTypes[2].byte);
 }
 
 TEST(GetPLDMVersion, testGoodEncodeRequest)
@@ -361,7 +371,7 @@
 
 TEST(GetPLDMVersion, testDecodeRequest)
 {
-    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, hdrSize + PLDM_GET_VERSION_REQ_BYTES> requestMsg{};
     uint32_t transferHandle = 0x0;
     uint32_t retTransferHandle = 0x0;
     uint8_t flag = PLDM_GET_FIRSTPART;
@@ -369,12 +379,16 @@
     uint8_t pldmType = PLDM_BASE;
     uint8_t retType = PLDM_BASE;
 
-    memcpy(requestMsg.data(), &transferHandle, sizeof(transferHandle));
-    memcpy(requestMsg.data() + sizeof(transferHandle), &flag, sizeof(flag));
-    memcpy(requestMsg.data() + sizeof(transferHandle) + sizeof(flag), &pldmType,
-           sizeof(pldmType));
+    memcpy(requestMsg.data() + hdrSize, &transferHandle,
+           sizeof(transferHandle));
+    memcpy(requestMsg.data() + sizeof(transferHandle) + hdrSize, &flag,
+           sizeof(flag));
+    memcpy(requestMsg.data() + sizeof(transferHandle) + sizeof(flag) + hdrSize,
+           &pldmType, sizeof(pldmType));
 
-    auto rc = decode_get_version_req(requestMsg.data(), requestMsg.size(),
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
+    auto rc = decode_get_version_req(request, requestMsg.size() - hdrSize,
                                      &retTransferHandle, &retFlag, &retType);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
@@ -385,7 +399,8 @@
 
 TEST(GetPLDMVersion, testDecodeResponse)
 {
-    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_RESP_BYTES>
+        responseMsg{};
     uint32_t transferHandle = 0x0;
     uint32_t retTransferHandle = 0x0;
     uint8_t flag = PLDM_START_AND_END;
@@ -395,15 +410,18 @@
     ver32_t versionOut;
     uint8_t completion_code;
 
-    memcpy(responseMsg.data() + sizeof(completionCode), &transferHandle,
-           sizeof(transferHandle));
-    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(transferHandle),
+    memcpy(responseMsg.data() + sizeof(completionCode) + hdrSize,
+           &transferHandle, sizeof(transferHandle));
+    memcpy(responseMsg.data() + sizeof(completionCode) +
+               sizeof(transferHandle) + hdrSize,
            &flag, sizeof(flag));
     memcpy(responseMsg.data() + sizeof(completionCode) +
-               sizeof(transferHandle) + sizeof(flag),
+               sizeof(transferHandle) + sizeof(flag) + hdrSize,
            &version, sizeof(version));
 
-    auto rc = decode_get_version_resp(responseMsg.data(), responseMsg.size(),
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+    auto rc = decode_get_version_resp(response, responseMsg.size() - hdrSize,
                                       &completion_code, &retTransferHandle,
                                       &retFlag, &versionOut);
     ASSERT_EQ(rc, PLDM_SUCCESS);
diff --git a/test/libpldm_bios_test.cpp b/test/libpldm_bios_test.cpp
index 3fde16a..495a0d2 100644
--- a/test/libpldm_bios_test.cpp
+++ b/test/libpldm_bios_test.cpp
@@ -7,6 +7,8 @@
 
 #include <gtest/gtest.h>
 
+constexpr auto hdrSize = sizeof(pldm_msg_hdr);
+
 TEST(GetDateTime, testEncodeRequest)
 {
     pldm_msg request{};
@@ -59,7 +61,7 @@
 
 TEST(GetDateTime, testDecodeResponse)
 {
-    std::array<uint8_t, PLDM_GET_DATE_TIME_RESP_BYTES> responseMsg{};
+    std::array<uint8_t, hdrSize + PLDM_GET_DATE_TIME_RESP_BYTES> responseMsg{};
 
     uint8_t completionCode = 0;
 
@@ -77,25 +79,29 @@
     uint8_t retMonth = 0;
     uint16_t retYear = 0;
 
-    memcpy(responseMsg.data() + sizeof(completionCode), &seconds,
+    memcpy(responseMsg.data() + sizeof(completionCode) + hdrSize, &seconds,
            sizeof(seconds));
-    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds),
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
+               hdrSize,
            &minutes, sizeof(minutes));
     memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
-               sizeof(minutes),
+               sizeof(minutes) + hdrSize,
            &hours, sizeof(hours));
     memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
-               sizeof(minutes) + sizeof(hours),
+               sizeof(minutes) + sizeof(hours) + hdrSize,
            &day, sizeof(day));
     memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
-               sizeof(minutes) + sizeof(hours) + sizeof(day),
+               sizeof(minutes) + sizeof(hours) + sizeof(day) + hdrSize,
            &month, sizeof(month));
     memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
-               sizeof(minutes) + sizeof(hours) + sizeof(day) + sizeof(month),
+               sizeof(minutes) + sizeof(hours) + sizeof(day) + sizeof(month) +
+               hdrSize,
            &year, sizeof(year));
 
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
     auto rc = decode_get_date_time_resp(
-        responseMsg.data(), responseMsg.size(), &completionCode, &retSeconds,
+        response, responseMsg.size() - hdrSize, &completionCode, &retSeconds,
         &retMinutes, &retHours, &retDay, &retMonth, &retYear);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
diff --git a/test/libpldm_platform_test.cpp b/test/libpldm_platform_test.cpp
index b046e3f..1010bd8 100644
--- a/test/libpldm_platform_test.cpp
+++ b/test/libpldm_platform_test.cpp
@@ -7,6 +7,8 @@
 
 #include <gtest/gtest.h>
 
+constexpr auto hdrSize = sizeof(pldm_msg_hdr);
+
 TEST(SetStateEffecterStates, testEncodeResponse)
 {
     std::array<uint8_t,
@@ -56,17 +58,20 @@
 
 TEST(SetStateEffecterStates, testGoodDecodeResponse)
 {
-    std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
+    std::array<uint8_t, hdrSize + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
         responseMsg{};
 
     uint8_t completion_code = 0xA0;
 
     uint8_t retcompletion_code = 0;
 
-    memcpy(responseMsg.data(), &completion_code, sizeof(completion_code));
+    memcpy(responseMsg.data() + hdrSize, &completion_code,
+           sizeof(completion_code));
+
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
 
     auto rc = decode_set_state_effecter_states_resp(
-        responseMsg.data(), responseMsg.size(), &retcompletion_code);
+        response, responseMsg.size() - hdrSize, &retcompletion_code);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, retcompletion_code);
@@ -74,7 +79,8 @@
 
 TEST(SetStateEffecterStates, testGoodDecodeRequest)
 {
-    std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, hdrSize + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES>
+        requestMsg{};
 
     uint16_t effecterId = 0x32;
     uint8_t compEffecterCnt = 0x2;
@@ -88,14 +94,17 @@
 
     std::array<set_effecter_state_field, 8> retStateField{};
 
-    memcpy(requestMsg.data(), &effecterId, sizeof(effecterId));
-    memcpy(requestMsg.data() + sizeof(effecterId), &compEffecterCnt,
+    memcpy(requestMsg.data() + hdrSize, &effecterId, sizeof(effecterId));
+    memcpy(requestMsg.data() + sizeof(effecterId) + hdrSize, &compEffecterCnt,
            sizeof(compEffecterCnt));
-    memcpy(requestMsg.data() + sizeof(effecterId) + sizeof(compEffecterCnt),
+    memcpy(requestMsg.data() + sizeof(effecterId) + sizeof(compEffecterCnt) +
+               hdrSize,
            &stateField, sizeof(stateField));
 
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
     auto rc = decode_set_state_effecter_states_req(
-        requestMsg.data(), requestMsg.size(), &retEffecterId,
+        request, requestMsg.size() - hdrSize, &retEffecterId,
         &retCompEffecterCnt, retStateField.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
@@ -109,7 +118,7 @@
 
 TEST(SetStateEffecterStates, testBadDecodeRequest)
 {
-    const uint8_t* msg = NULL;
+    const struct pldm_msg* msg = NULL;
 
     auto rc = decode_set_state_effecter_states_req(msg, sizeof(*msg), NULL,
                                                    NULL, NULL);
@@ -122,7 +131,9 @@
     std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
         responseMsg{};
 
-    auto rc = decode_set_state_effecter_states_resp(responseMsg.data(),
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+    auto rc = decode_set_state_effecter_states_resp(response,
                                                     responseMsg.size(), NULL);
 
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);