diff --git a/libpldm/base.c b/libpldm/base.c
index afba5a1..18a12a6 100644
--- a/libpldm/base.c
+++ b/libpldm/base.c
@@ -90,10 +90,8 @@
 	header.command = PLDM_GET_PLDM_COMMANDS;
 	pack_pldm_header(&header, &(msg->hdr));
 
-	uint8_t *dst = msg->body.payload;
-	memcpy(dst, &type, sizeof(type));
-	dst += sizeof(type);
-	memcpy(dst, &version, sizeof(version));
+	memcpy(msg->payload, &type, sizeof(type));
+	memcpy(msg->payload + sizeof(type), &version, sizeof(version));
 
 	return PLDM_SUCCESS;
 }
@@ -105,7 +103,7 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	msg->body.payload[0] = completion_code;
+	msg->payload[0] = completion_code;
 
 	struct pldm_header_info header = {0};
 	header.instance = instance_id;
@@ -113,27 +111,30 @@
 	header.command = PLDM_GET_PLDM_TYPES;
 	pack_pldm_header(&header, &(msg->hdr));
 
-	if (msg->body.payload[0] == PLDM_SUCCESS) {
+	if (msg->payload[0] == PLDM_SUCCESS) {
 		if (types == NULL) {
 			return PLDM_ERROR_INVALID_DATA;
 		}
-		uint8_t *dst = msg->body.payload + sizeof(msg->body.payload[0]);
-		memcpy(dst, &(types->byte), PLDM_MAX_TYPES / 8);
+		memcpy(msg->payload + sizeof(completion_code), &(types->byte),
+		       PLDM_MAX_TYPES / 8);
 	}
 
 	return PLDM_SUCCESS;
 }
 
-int decode_get_commands_req(const struct pldm_msg_payload *msg, uint8_t *type,
-			    ver32_t *version)
+int decode_get_commands_req(const uint8_t *msg, size_t payload_length,
+			    uint8_t *type, ver32_t *version)
 {
 	if (msg == NULL || type == NULL || version == NULL) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	const uint8_t *start = msg->payload;
-	*type = *start;
-	memcpy(version, (ver32_t *)(start + sizeof(*type)), sizeof(*version));
+	if (payload_length != PLDM_GET_COMMANDS_REQ_BYTES) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	*type = *msg;
+	memcpy(version, (ver32_t *)(msg + sizeof(*type)), sizeof(*version));
 
 	return PLDM_SUCCESS;
 }
@@ -145,7 +146,7 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	msg->body.payload[0] = completion_code;
+	msg->payload[0] = completion_code;
 
 	struct pldm_header_info header = {0};
 	header.instance = instance_id;
@@ -153,51 +154,57 @@
 	header.command = PLDM_GET_PLDM_COMMANDS;
 	pack_pldm_header(&header, &(msg->hdr));
 
-	if (msg->body.payload[0] == PLDM_SUCCESS) {
+	if (msg->payload[0] == PLDM_SUCCESS) {
 		if (commands == NULL) {
 			return PLDM_ERROR_INVALID_DATA;
 		}
-		uint8_t *dst = msg->body.payload + sizeof(msg->body.payload[0]);
-		memcpy(dst, &(commands->byte), PLDM_MAX_CMDS_PER_TYPE / 8);
+		memcpy(msg->payload + sizeof(completion_code),
+		       &(commands->byte), PLDM_MAX_CMDS_PER_TYPE / 8);
 	}
 
 	return PLDM_SUCCESS;
 }
 
-int decode_get_types_resp(const struct pldm_msg_payload *msg,
+int decode_get_types_resp(const uint8_t *msg, size_t payload_length,
 			  uint8_t *completion_code, bitfield8_t *types)
 {
-	if (msg == NULL || types == NULL || msg->payload == NULL ||
-	    completion_code == NULL) {
+	if (msg == NULL || types == NULL || completion_code == NULL) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	*completion_code = msg->payload[0];
+	if (payload_length != PLDM_GET_TYPES_RESP_BYTES) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	*completion_code = msg[0];
 	if (PLDM_SUCCESS != *completion_code) {
 		return PLDM_SUCCESS;
 	};
 
-	const uint8_t *src = msg->payload + sizeof(uint8_t);
-	memcpy(&(types->byte), src, PLDM_MAX_TYPES / 8);
+	memcpy(&(types->byte), msg + sizeof(*completion_code),
+	       PLDM_MAX_TYPES / 8);
 
 	return PLDM_SUCCESS;
 }
 
-int decode_get_commands_resp(const struct pldm_msg_payload *msg,
+int decode_get_commands_resp(const uint8_t *msg, size_t payload_length,
 			     uint8_t *completion_code, bitfield8_t *commands)
 {
-	if (msg == NULL || commands == NULL || msg->payload == NULL ||
-	    completion_code == NULL) {
+	if (msg == NULL || commands == NULL || completion_code == NULL) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	*completion_code = msg->payload[0];
+	if (payload_length != PLDM_GET_COMMANDS_RESP_BYTES) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	*completion_code = msg[0];
 	if (PLDM_SUCCESS != *completion_code) {
 		return PLDM_SUCCESS;
 	};
 
-	const uint8_t *src = msg->payload + sizeof(uint8_t);
-	memcpy(&(commands->byte), src, PLDM_MAX_CMDS_PER_TYPE / 8);
+	memcpy(&(commands->byte), msg + sizeof(*completion_code),
+	       PLDM_MAX_CMDS_PER_TYPE / 8);
 
 	return PLDM_SUCCESS;
 }
@@ -222,15 +229,14 @@
 		return rc;
 	}
 
-	uint8_t *dst = msg->body.payload;
 	transfer_handle = htole32(transfer_handle);
-	memcpy(dst, &transfer_handle, sizeof(transfer_handle));
-	dst += sizeof(transfer_handle);
+	memcpy(msg->payload, &transfer_handle, sizeof(transfer_handle));
 
-	memcpy(dst, &transfer_opflag, sizeof(transfer_opflag));
-	dst += sizeof(transfer_opflag);
+	memcpy(msg->payload + sizeof(transfer_handle), &transfer_opflag,
+	       sizeof(transfer_opflag));
 
-	memcpy(dst, &type, sizeof(type));
+	memcpy(msg->payload + sizeof(transfer_handle) + sizeof(transfer_opflag),
+	       &type, sizeof(type));
 
 	return PLDM_SUCCESS;
 }
@@ -243,8 +249,8 @@
 	struct pldm_header_info header = {0};
 	int rc = PLDM_SUCCESS;
 
-	msg->body.payload[0] = completion_code;
-	if (msg->body.payload[0] == PLDM_SUCCESS) {
+	msg->payload[0] = completion_code;
+	if (msg->payload[0] == PLDM_SUCCESS) {
 
 		header.msg_type = PLDM_RESPONSE;
 		header.instance = instance_id;
@@ -255,54 +261,64 @@
 		    PLDM_SUCCESS) {
 			return rc;
 		}
-		uint8_t *dst = msg->body.payload + sizeof(msg->body.payload[0]);
-
 		next_transfer_handle = htole32(next_transfer_handle);
 
-		memcpy(dst, &next_transfer_handle,
-		       sizeof(next_transfer_handle));
-		dst += sizeof(next_transfer_handle);
-		memcpy(dst, &transfer_flag, sizeof(transfer_flag));
+		memcpy(msg->payload + sizeof(msg->payload[0]),
+		       &next_transfer_handle, sizeof(next_transfer_handle));
 
-		dst += sizeof(transfer_flag);
-		memcpy(dst, version_data, version_size);
+		memcpy(msg->payload + sizeof(msg->payload[0]) +
+			   sizeof(next_transfer_handle),
+		       &transfer_flag, sizeof(transfer_flag));
+
+		memcpy(msg->payload + sizeof(msg->payload[0]) +
+			   sizeof(next_transfer_handle) + sizeof(transfer_flag),
+		       version_data, version_size);
 	}
 	return PLDM_SUCCESS;
 }
 
-int decode_get_version_req(const struct pldm_msg_payload *msg,
+int decode_get_version_req(const uint8_t *msg, size_t payload_length,
 			   uint32_t *transfer_handle, uint8_t *transfer_opflag,
 			   uint8_t *type)
 {
-	const uint8_t *start = msg->payload;
-	*transfer_handle = le32toh(*((uint32_t *)start));
-	*transfer_opflag = *(start + sizeof(*transfer_handle));
-	*type = *(start + sizeof(*transfer_handle) + sizeof(*transfer_opflag));
+
+	if (payload_length != PLDM_GET_VERSION_REQ_BYTES) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	*transfer_handle = le32toh(*((uint32_t *)msg));
+	*transfer_opflag = *(msg + sizeof(*transfer_handle));
+	*type = *(msg + sizeof(*transfer_handle) + sizeof(*transfer_opflag));
 
 	return PLDM_SUCCESS;
 }
 
-int decode_get_version_resp(const struct pldm_msg_payload *msg,
+int decode_get_version_resp(const uint8_t *msg, size_t payload_length,
 			    uint8_t *completion_code,
 			    uint32_t *next_transfer_handle,
 			    uint8_t *transfer_flag, ver32_t *version)
 {
 	if (msg == NULL || next_transfer_handle == NULL ||
-	    transfer_flag == NULL || msg->payload == NULL ||
-	    completion_code == NULL) {
+	    transfer_flag == NULL || completion_code == NULL) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	*completion_code = msg->payload[0];
+	if (payload_length < PLDM_GET_VERSION_RESP_BYTES) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	*completion_code = msg[0];
 	if (PLDM_SUCCESS != *completion_code) {
 		return PLDM_SUCCESS;
 	};
 
-	const uint8_t *start = msg->payload + sizeof(uint8_t);
-	*next_transfer_handle = le32toh(*((uint32_t *)start));
-	*transfer_flag = *(start + sizeof(*next_transfer_handle));
+	*next_transfer_handle =
+	    le32toh(*((uint32_t *)(msg + sizeof(*completion_code))));
+	*transfer_flag =
+	    *(msg + sizeof(*completion_code) + sizeof(*next_transfer_handle));
 
-	*version = *((ver32_t *)(start + sizeof(*next_transfer_handle) +
+	*version = *((ver32_t *)(msg + sizeof(*completion_code) +
+				 sizeof(*next_transfer_handle) +
 				 sizeof(*transfer_flag)));
 
 	return PLDM_SUCCESS;
diff --git a/libpldm/base.h b/libpldm/base.h
index 77b1045..14aa518 100644
--- a/libpldm/base.h
+++ b/libpldm/base.h
@@ -103,22 +103,13 @@
 	uint8_t command; //!< PLDM command code
 } __attribute__((packed));
 
-/** @struct pldm_msg_payload
- *
- * Structure representing PLDM message payload
- */
-struct pldm_msg_payload {
-	uint8_t *payload;      //!< Pointer to PLDM message payload
-	size_t payload_length; //!< PLDM message payload's length in bytes
-} __attribute__((packed));
-
 /** @struct pldm_msg
  *
  * Structure representing PLDM message
  */
 struct pldm_msg {
-	struct pldm_msg_hdr hdr;      //!< PLDM message header
-	struct pldm_msg_payload body; //!< PLDM message payload
+	struct pldm_msg_hdr hdr; //!< PLDM message header
+	uint8_t payload[1]; //!< &payload[0] is the beginning of the payload
 } __attribute__((packed));
 
 /** @struct pldm_header_info
@@ -168,19 +159,20 @@
  *  @param[in,out] msg - Message will be written to this
  *  @return pldm_completion_codes
  *  @note  Caller is responsible for memory alloc and dealloc of param
- *         'msg.body.payload'
+ *         'msg.payload'
  */
 int encode_get_types_req(uint8_t instance_id, struct pldm_msg *msg);
 
 /** @brief Decode a GetPLDMTypes response message
  *
  *  @param[in] msg - Response message payload
+ *  @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 struct pldm_msg_payload *msg,
+int decode_get_types_resp(const uint8_t *msg, size_t payload_length,
 			  uint8_t *completion_code, bitfield8_t *types);
 
 /* GetPLDMCommands */
@@ -193,7 +185,7 @@
  *  @param[in,out] msg - Message will be written to this
  *  @return pldm_completion_codes
  *  @note  Caller is responsible for memory alloc and dealloc of param
- *         'msg.body.payload'
+ *         'msg.payload'
  */
 int encode_get_commands_req(uint8_t instance_id, uint8_t type, ver32_t version,
 			    struct pldm_msg *msg);
@@ -201,12 +193,13 @@
 /** @brief Decode a GetPLDMCommands response message
  *
  *  @param[in] msg - Response message payload
+ *  @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 struct pldm_msg_payload *msg,
+int decode_get_commands_resp(const uint8_t *msg, size_t payload_length,
 			     uint8_t *completion_code, bitfield8_t *commands);
 
 /* GetPLDMVersion */
@@ -223,7 +216,7 @@
  *  @param[in,out] msg - Message will be written to this
  *  @return pldm_completion_codes
  *  @note  Caller is responsible for memory alloc and dealloc of param
- *         'msg.body.payload'
+ *         'msg.payload'
  */
 int encode_get_version_req(uint8_t instance_id, uint32_t transfer_handle,
 			   uint8_t transfer_opflag, uint8_t type,
@@ -232,12 +225,13 @@
 /** @brief Decode a GetPLDMVersion response message
  *
  *  @param[in] msg - Response message payload
+ *  @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 struct pldm_msg_payload *msg,
+int decode_get_version_resp(const uint8_t *msg, size_t payload_length,
 			    uint8_t *completion_code,
 			    uint32_t *next_transfer_handle,
 			    uint8_t *transfer_flag, ver32_t *version);
@@ -255,7 +249,7 @@
  *  @param[in,out] msg - Message will be written to this
  *  @return pldm_completion_codes
  *  @note  Caller is responsible for memory alloc and dealloc of param
- *         'msg.body.payload'
+ *         'msg.payload'
  */
 int encode_get_types_resp(uint8_t instance_id, uint8_t completion_code,
 			  const bitfield8_t *types, struct pldm_msg *msg);
@@ -264,13 +258,14 @@
 
 /** @brief Decode GetPLDMCommands' request data
  *
- *  @param[in] msg - Request message payload
+ *  @param[in] msg - Request message
+ *  @param[in] payload_length - Length of request message payload
  *  @param[out] type - PLDM Type
  *  @param[out] version - Version for PLDM Type
  *  @return pldm_completion_codes
  */
-int decode_get_commands_req(const struct pldm_msg_payload *msg, uint8_t *type,
-			    ver32_t *version);
+int decode_get_commands_req(const uint8_t *msg, size_t payload_length,
+			    uint8_t *type, ver32_t *version);
 
 /** @brief Create a PLDM response message for GetPLDMCommands
  *
@@ -281,7 +276,7 @@
  *  @param[in,out] msg - Message will be written to this
  *  @return pldm_completion_codes
  *  @note  Caller is responsible for memory alloc and dealloc of param
- *         'msg.body.payload'
+ *         'msg.payload'
  */
 int encode_get_commands_resp(uint8_t instance_id, uint8_t completion_code,
 			     const bitfield8_t *commands, struct pldm_msg *msg);
@@ -300,7 +295,7 @@
  *  @param[in,out] msg - Message will be written to this
  *  @return pldm_completion_codes
  *  @note  Caller is responsible for memory alloc and dealloc of param
- *         'msg.body.payload'
+ *         'msg.payload'
  */
 int encode_get_version_resp(uint8_t instance_id, uint8_t completion_code,
 			    uint32_t next_transfer_handle,
@@ -309,13 +304,14 @@
 
 /** @brief Decode a GetPLDMVersion request message
  *
- *  @param[in] msg - Request message payload
+ *  @param[in] msg - Request message
+ *  @param[in] payload_length - length of request message payload
  *  @param[out] transfer_handle - the handle of data
  *  @param[out] transfer_opflag - Transfer Flag
  *  @param[out] type - PLDM type for which version is requested
  *  @return pldm_completion_codes
  */
-int decode_get_version_req(const struct pldm_msg_payload *msg,
+int decode_get_version_req(const uint8_t *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 c757df3..6470dc3 100644
--- a/libpldm/bios.c
+++ b/libpldm/bios.c
@@ -30,7 +30,7 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	msg->body.payload[0] = completion_code;
+	msg->payload[0] = completion_code;
 
 	header.msg_type = PLDM_RESPONSE;
 	header.instance = instance_id;
@@ -40,7 +40,7 @@
 		return rc;
 	}
 
-	uint8_t *dst = msg->body.payload + sizeof(msg->body.payload[0]);
+	uint8_t *dst = msg->payload + sizeof(msg->payload[0]);
 
 	memcpy(dst, &seconds, sizeof(seconds));
 	dst += sizeof(seconds);
@@ -58,7 +58,7 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_get_date_time_resp(const struct pldm_msg_payload *msg,
+int decode_get_date_time_resp(const uint8_t *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)
@@ -69,20 +69,26 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	*completion_code = msg->payload[0];
+	if (payload_length != PLDM_GET_DATE_TIME_RESP_BYTES) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	*completion_code = msg[0];
 	if (PLDM_SUCCESS != *completion_code) {
 		return PLDM_SUCCESS;
 	}
-	const uint8_t *start = msg->payload + sizeof(uint8_t);
-	*seconds = *start;
-	*minutes = *(start + sizeof(*seconds));
-	*hours = *(start + sizeof(*seconds) + sizeof(*minutes));
-	*day = *(start + sizeof(*seconds) + sizeof(*minutes) + sizeof(*hours));
-	*month = *(start + sizeof(*seconds) + sizeof(*minutes) +
-		   sizeof(*hours) + sizeof(*day));
+	*seconds = *(msg + sizeof(*completion_code));
+	*minutes = *(msg + sizeof(*completion_code) + sizeof(*seconds));
+	*hours = *(msg + sizeof(*completion_code) + sizeof(*seconds) +
+		   sizeof(*minutes));
+	*day = *(msg + sizeof(*completion_code) + sizeof(*seconds) +
+		 sizeof(*minutes) + sizeof(*hours));
+	*month = *(msg + sizeof(*completion_code) + sizeof(*seconds) +
+		   sizeof(*minutes) + sizeof(*hours) + sizeof(*day));
 	*year = le16toh(
-	    *((uint16_t *)(start + sizeof(*seconds) + sizeof(*minutes) +
-			   sizeof(*hours) + sizeof(*day) + sizeof(*month))));
+	    *((uint16_t *)(msg + sizeof(*completion_code) + sizeof(*seconds) +
+			   sizeof(*minutes) + sizeof(*hours) + sizeof(*day) +
+			   sizeof(*month))));
 
 	return PLDM_SUCCESS;
 }
diff --git a/libpldm/bios.h b/libpldm/bios.h
index d173aeb..4bc00ed 100644
--- a/libpldm/bios.h
+++ b/libpldm/bios.h
@@ -34,6 +34,7 @@
 /** @brief Decode a GetDateTime response message
  *
  *  @param[in] msg - Response message payload
+ *  @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
  *  @param[out] minutes - minutes in BCD format
@@ -43,7 +44,7 @@
  *  @param[out] year - year in BCD format
  *  @return pldm_completion_codes
  */
-int decode_get_date_time_resp(const struct pldm_msg_payload *msg,
+int decode_get_date_time_resp(const uint8_t *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 9d3a427..cfd72d4 100644
--- a/libpldm/platform.c
+++ b/libpldm/platform.c
@@ -10,7 +10,7 @@
 	struct pldm_header_info header = {0};
 	int rc = PLDM_SUCCESS;
 
-	msg->body.payload[0] = completion_code;
+	msg->payload[0] = completion_code;
 
 	header.msg_type = PLDM_RESPONSE;
 	header.instance = instance_id;
@@ -44,7 +44,7 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	uint8_t *encoded_msg = msg->body.payload;
+	uint8_t *encoded_msg = msg->payload;
 	effecter_id = htole16(effecter_id);
 	memcpy(encoded_msg, &effecter_id, sizeof(effecter_id));
 	encoded_msg += sizeof(effecter_id);
@@ -56,19 +56,25 @@
 	return PLDM_SUCCESS;
 }
 
-int decode_set_state_effecter_states_resp(const struct pldm_msg_payload *msg,
+int decode_set_state_effecter_states_resp(const uint8_t *msg,
+					  size_t payload_length,
 					  uint8_t *completion_code)
 {
 	if (msg == NULL || completion_code == NULL) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	*completion_code = *(uint8_t *)msg->payload;
+	if (payload_length > PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	*completion_code = msg[0];
 
 	return PLDM_SUCCESS;
 }
 
-int decode_set_state_effecter_states_req(const struct pldm_msg_payload *msg,
+int decode_set_state_effecter_states_req(const uint8_t *msg,
+					 size_t payload_length,
 					 uint16_t *effecter_id,
 					 uint8_t *comp_effecter_count,
 					 set_effecter_state_field *field)
@@ -77,11 +83,15 @@
 	    field == NULL) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
-	const uint8_t *start = msg->payload;
-	*effecter_id = le16toh(*((uint16_t *)start));
-	*comp_effecter_count = *(start + sizeof(*effecter_id));
+
+	if (payload_length > PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
+	*effecter_id = le16toh(*((uint16_t *)msg));
+	*comp_effecter_count = *(msg + sizeof(*effecter_id));
 	memcpy(field,
-	       (start + sizeof(*effecter_id) + sizeof(*comp_effecter_count)),
+	       (msg + sizeof(*effecter_id) + sizeof(*comp_effecter_count)),
 	       (sizeof(set_effecter_state_field) * (*comp_effecter_count)));
 
 	return PLDM_SUCCESS;
diff --git a/libpldm/platform.h b/libpldm/platform.h
index 42169db..a5bfe4e 100644
--- a/libpldm/platform.h
+++ b/libpldm/platform.h
@@ -53,6 +53,7 @@
 /** @brief Decode SetStateEffecterStates request data
  *
  *  @param[in] msg - Request message payload
+ *  @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
  *         information. Upto eight sets of state effecter info can be accessed
@@ -66,7 +67,9 @@
  *         always, which is 8 in number.
  *  @return pldm_completion_codes
  */
-int decode_set_state_effecter_states_req(const struct pldm_msg_payload *msg,
+
+int decode_set_state_effecter_states_req(const uint8_t *msg,
+					 size_t payload_length,
 					 uint16_t *effecter_id,
 					 uint8_t *comp_effecter_count,
 					 set_effecter_state_field *field);
@@ -88,7 +91,7 @@
  *  @param[out] msg - Message will be written to this
  *  @return pldm_completion_codes
  *  @note  Caller is responsible for memory alloc and dealloc of param
- *         'msg.body.payload'
+ *         'msg.payload'
  */
 
 int encode_set_state_effecter_states_req(uint8_t instance_id,
@@ -99,12 +102,13 @@
 
 /** @brief Decode SetStateEffecterStates response data
  *  @param[in] msg - Request message payload
+ *  @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 struct pldm_msg_payload *msg,
+int decode_set_state_effecter_states_resp(const uint8_t *msg,
+					  size_t payload_length,
 					  uint8_t *completion_code);
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/libpldmresponder/base.cpp b/libpldmresponder/base.cpp
index 6ae8ba6..37b4a63 100644
--- a/libpldmresponder/base.cpp
+++ b/libpldmresponder/base.cpp
@@ -22,7 +22,7 @@
     {PLDM_BASE, {0xF1, 0xF0, 0xF0, 0x00}},
 };
 
-void getPLDMTypes(const pldm_msg_payload* request, pldm_msg* response)
+Response getPLDMTypes(const pldm_msg* request, size_t payloadLength)
 {
     // DSP0240 has this as a bitfield8[N], where N = 0 to 7
     std::array<bitfield8_t, 8> types{};
@@ -34,30 +34,37 @@
         types[index].byte |= 1 << bit;
     }
 
-    encode_get_types_resp(0, PLDM_SUCCESS, types.data(), response);
+    Response response(sizeof(pldm_msg_hdr) + PLDM_GET_TYPES_RESP_BYTES, 0);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    encode_get_types_resp(0, PLDM_SUCCESS, types.data(), responsePtr);
+
+    return response;
 }
 
-void getPLDMCommands(const pldm_msg_payload* request, pldm_msg* response)
+Response getPLDMCommands(const pldm_msg* request, size_t payloadLength)
 {
     ver32_t version{};
     Type type;
 
-    if (request->payload_length != (sizeof(version) + sizeof(type)))
-    {
-        encode_get_commands_resp(0, PLDM_ERROR_INVALID_LENGTH, nullptr,
-                                 response);
-        return;
-    }
+    Response response(sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_RESP_BYTES, 0);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    decode_get_commands_req(request, &type, &version);
+    auto rc = decode_get_commands_req(request->payload, payloadLength, &type,
+                                      &version);
+
+    if (rc != PLDM_SUCCESS)
+    {
+        encode_get_commands_resp(0, rc, nullptr, responsePtr);
+        return response;
+    }
 
     // DSP0240 has this as a bitfield8[N], where N = 0 to 31
     std::array<bitfield8_t, 32> cmds{};
     if (capabilities.find(type) == capabilities.end())
     {
         encode_get_commands_resp(0, PLDM_ERROR_INVALID_PLDM_TYPE, nullptr,
-                                 response);
-        return;
+                                 responsePtr);
+        return response;
     }
 
     for (const auto& cmd : capabilities.at(type))
@@ -68,24 +75,28 @@
         cmds[index].byte |= 1 << bit;
     }
 
-    encode_get_commands_resp(0, PLDM_SUCCESS, cmds.data(), response);
+    encode_get_commands_resp(0, PLDM_SUCCESS, cmds.data(), responsePtr);
+
+    return response;
 }
 
-void getPLDMVersion(const pldm_msg_payload* request, pldm_msg* response)
+Response getPLDMVersion(const pldm_msg* request, size_t payloadLength)
 {
     uint32_t transferHandle;
     Type type;
     uint8_t transferFlag;
 
-    if (request->payload_length !=
-        (sizeof(transferHandle) + sizeof(type) + sizeof(transferFlag)))
-    {
-        encode_get_version_resp(0, PLDM_ERROR_INVALID_LENGTH, 0, 0, nullptr, 0,
-                                response);
-        return;
-    }
+    Response response(sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_RESP_BYTES, 0);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    decode_get_version_req(request, &transferHandle, &transferFlag, &type);
+    uint8_t rc = decode_get_version_req(request->payload, payloadLength,
+                                        &transferHandle, &transferFlag, &type);
+
+    if (rc != PLDM_SUCCESS)
+    {
+        encode_get_version_resp(0, rc, 0, 0, nullptr, 4, responsePtr);
+        return response;
+    }
 
     ver32_t version{};
     auto search = versions.find(type);
@@ -93,13 +104,15 @@
     if (search == versions.end())
     {
         encode_get_version_resp(0, PLDM_ERROR_INVALID_PLDM_TYPE, 0, 0, nullptr,
-                                0, response);
-        return;
+                                4, responsePtr);
+        return response;
     }
 
     memcpy(&version, &(search->second), sizeof(version));
     encode_get_version_resp(0, PLDM_SUCCESS, 0, PLDM_START_AND_END, &version,
-                            sizeof(pldm_version), response);
+                            sizeof(pldm_version), responsePtr);
+
+    return response;
 }
 
 } // namespace responder
diff --git a/libpldmresponder/base.hpp b/libpldmresponder/base.hpp
index 74bc4af..466559a 100644
--- a/libpldmresponder/base.hpp
+++ b/libpldmresponder/base.hpp
@@ -11,29 +11,33 @@
 
 using Type = uint8_t;
 
+using Response = std::vector<uint8_t>;
+
 namespace responder
 {
 
 /** @brief Handler for getPLDMTypes
  *
  *  @param[in] request - Request message payload
- *  @param[out] response - Response message written here
+ *  @param[in] payload_length - Request message payload length
+ *  @param[return] Response - PLDM Response message
  */
-void getPLDMTypes(const pldm_msg_payload* request, pldm_msg* response);
+Response getPLDMTypes(const pldm_msg* request, size_t payloadLength);
 
 /** @brief Handler for getPLDMCommands
  *
  *  @param[in] request - Request message payload
- *  @param[out] response - Response message written here
+ *  @param[in] payload_length - Request message payload length
+ *  @param[return] Response - PLDM Response message
  */
-void getPLDMCommands(const pldm_msg_payload* request, pldm_msg* response);
+Response getPLDMCommands(const pldm_msg* request, size_t payloadLength);
 
 /** @brief Handler for getPLDMCommands
  *
  *  @param[in] request - Request message payload
- *  @param[out] response - Response messsage written here
+ *  @param[in] payload_length - Request message payload length
+ *  @param[return] Response - PLDM Response message
  */
-void getPLDMVersion(const pldm_msg_payload* request, pldm_msg* response);
-
+Response getPLDMVersion(const pldm_msg* request, size_t payloadLength);
 } // namespace responder
 } // namespace pldm
diff --git a/libpldmresponder/bios.cpp b/libpldmresponder/bios.cpp
index 5c4a270..11c8251 100644
--- a/libpldmresponder/bios.cpp
+++ b/libpldmresponder/bios.cpp
@@ -47,7 +47,7 @@
 
 } // namespace utils
 
-void getDateTime(const pldm_msg_payload* request, pldm_msg* response)
+Response getDateTime(const pldm_msg* request)
 {
     uint8_t seconds = 0;
     uint8_t minutes = 0;
@@ -58,6 +58,8 @@
 
     constexpr auto timeInterface = "xyz.openbmc_project.Time.EpochTime";
     constexpr auto bmcTimePath = "/xyz/openbmc_project/time/bmc";
+    Response response(sizeof(pldm_msg_hdr) + PLDM_GET_DATE_TIME_RESP_BYTES, 0);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     std::variant<EpochTimeUS> value;
 
     auto bus = sdbusplus::bus::new_default();
@@ -79,8 +81,8 @@
                         entry("TIME INTERACE=%s", timeInterface));
 
         encode_get_date_time_resp(0, PLDM_ERROR, seconds, minutes, hours, day,
-                                  month, year, response);
-        return;
+                                  month, year, responsePtr);
+        return response;
     }
 
     uint64_t timeUsec = std::get<EpochTimeUS>(value);
@@ -92,7 +94,8 @@
     utils::epochToBCDTime(timeSec, seconds, minutes, hours, day, month, year);
 
     encode_get_date_time_resp(0, PLDM_SUCCESS, seconds, minutes, hours, day,
-                              month, year, response);
+                              month, year, responsePtr);
+    return response;
 }
 
 } // namespace responder
diff --git a/libpldmresponder/bios.hpp b/libpldmresponder/bios.hpp
index 80a732b..915a367 100644
--- a/libpldmresponder/bios.hpp
+++ b/libpldmresponder/bios.hpp
@@ -2,20 +2,24 @@
 
 #include <stdint.h>
 
+#include <vector>
+
 #include "libpldm/bios.h"
 
 namespace pldm
 {
 
+using Response = std::vector<uint8_t>;
+
 namespace responder
 {
 
 /** @brief Handler for GetDateTime
  *
  *  @param[in] request - Request message payload
- *  @param[out] response - Response message written here
+ *  @param[return] Response - PLDM Response message
  */
-void getDateTime(const pldm_msg_payload* request, pldm_msg* response);
+Response getDateTime(const pldm_msg* request);
 
 namespace utils
 {
diff --git a/test/libpldm_base_test.cpp b/test/libpldm_base_test.cpp
index f906f77..faa4d90 100644
--- a/test/libpldm_base_test.cpp
+++ b/test/libpldm_base_test.cpp
@@ -191,15 +191,14 @@
 {
     uint8_t pldmType = 0x05;
     ver32_t version{0xFF, 0xFF, 0xFF, 0xFF};
-    std::array<uint8_t, PLDM_GET_COMMANDS_REQ_BYTES> requestMsg{};
-    pldm_msg request{};
-    request.body.payload = requestMsg.data();
-    request.body.payload_length = requestMsg.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES>
+        requestMsg{};
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
 
-    auto rc = encode_get_commands_req(0, pldmType, version, &request);
+    auto rc = encode_get_commands_req(0, pldmType, version, request);
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(0, memcmp(request.body.payload, &pldmType, sizeof(pldmType)));
-    ASSERT_EQ(0, memcmp(request.body.payload + sizeof(pldmType), &version,
+    ASSERT_EQ(0, memcmp(request->payload, &pldmType, sizeof(pldmType)));
+    ASSERT_EQ(0, memcmp(request->payload + sizeof(pldmType), &version,
                         sizeof(version)));
 }
 
@@ -210,13 +209,11 @@
     uint8_t pldmTypeOut{};
     ver32_t versionOut{0xFF, 0xFF, 0xFF, 0xFF};
     std::array<uint8_t, PLDM_GET_COMMANDS_REQ_BYTES> requestMsg{};
-    pldm_msg_payload request{};
-    request.payload = requestMsg.data();
-    request.payload_length = requestMsg.size();
 
-    memcpy(request.payload, &pldmType, sizeof(pldmType));
-    memcpy(request.payload + sizeof(pldmType), &version, sizeof(version));
-    auto rc = decode_get_commands_req(&request, &pldmTypeOut, &versionOut);
+    memcpy(requestMsg.data(), &pldmType, sizeof(pldmType));
+    memcpy(requestMsg.data() + sizeof(pldmType), &version, sizeof(version));
+    auto rc = decode_get_commands_req(requestMsg.data(), requestMsg.size(),
+                                      &pldmTypeOut, &versionOut);
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(pldmTypeOut, pldmType);
     ASSERT_EQ(0, memcmp(&versionOut, &version, sizeof(version)));
@@ -225,108 +222,104 @@
 TEST(GetPLDMCommands, testEncodeResponse)
 {
     uint8_t completionCode = 0;
-    std::array<uint8_t, PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
-    pldm_msg response{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_RESP_BYTES>
+        responseMsg{};
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
     std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> commands{};
     commands[0].byte = 1;
     commands[1].byte = 2;
     commands[2].byte = 3;
 
     auto rc =
-        encode_get_commands_resp(0, PLDM_SUCCESS, commands.data(), &response);
+        encode_get_commands_resp(0, PLDM_SUCCESS, commands.data(), response);
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(completionCode, response.body.payload[0]);
-    ASSERT_EQ(1, response.body.payload[1]);
-    ASSERT_EQ(2, response.body.payload[2]);
-    ASSERT_EQ(3, response.body.payload[3]);
+    uint8_t* payload_ptr = response->payload;
+    ASSERT_EQ(completionCode, payload_ptr[0]);
+    ASSERT_EQ(1, payload_ptr[sizeof(completionCode)]);
+    ASSERT_EQ(2,
+              payload_ptr[sizeof(completionCode) + sizeof(commands[0].byte)]);
+    ASSERT_EQ(3, payload_ptr[sizeof(completionCode) + sizeof(commands[0].byte) +
+                             sizeof(commands[1].byte)]);
 }
 
 TEST(GetPLDMTypes, testEncodeResponse)
 {
     uint8_t completionCode = 0;
-    std::array<uint8_t, PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
-    pldm_msg response{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_TYPES_RESP_BYTES>
+        responseMsg{};
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
     std::array<bitfield8_t, PLDM_MAX_TYPES / 8> types{};
     types[0].byte = 1;
     types[1].byte = 2;
     types[2].byte = 3;
 
-    auto rc = encode_get_types_resp(0, PLDM_SUCCESS, types.data(), &response);
+    auto rc = encode_get_types_resp(0, PLDM_SUCCESS, types.data(), response);
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(completionCode, response.body.payload[0]);
-    ASSERT_EQ(1, response.body.payload[1]);
-    ASSERT_EQ(2, response.body.payload[2]);
-    ASSERT_EQ(3, response.body.payload[3]);
+    uint8_t* payload_ptr = response->payload;
+    ASSERT_EQ(completionCode, payload_ptr[0]);
+    ASSERT_EQ(1, payload_ptr[sizeof(completionCode)]);
+    ASSERT_EQ(2, payload_ptr[sizeof(completionCode) + sizeof(types[0].byte)]);
+    ASSERT_EQ(3, payload_ptr[sizeof(completionCode) + sizeof(types[0].byte) +
+                             sizeof(types[1].byte)]);
 }
 
 TEST(GetPLDMTypes, testDecodeResponse)
 {
     std::array<uint8_t, PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
-    response.payload[1] = 1;
-    response.payload[2] = 2;
-    response.payload[3] = 3;
+    responseMsg[1] = 1;
+    responseMsg[2] = 2;
+    responseMsg[3] = 3;
     std::array<bitfield8_t, PLDM_MAX_TYPES / 8> outTypes{};
     uint8_t completion_code;
 
-    auto rc =
-        decode_get_types_resp(&response, &completion_code, outTypes.data());
+    auto rc = decode_get_types_resp(responseMsg.data(), responseMsg.size(),
+                                    &completion_code, outTypes.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(response.payload[1], outTypes[0].byte);
-    ASSERT_EQ(response.payload[2], outTypes[1].byte);
-    ASSERT_EQ(response.payload[3], outTypes[2].byte);
+    ASSERT_EQ(responseMsg[1], outTypes[0].byte);
+    ASSERT_EQ(responseMsg[2], outTypes[1].byte);
+    ASSERT_EQ(responseMsg[3], outTypes[2].byte);
 }
 
 TEST(GetPLDMCommands, testDecodeResponse)
 {
-    std::array<uint8_t, PLDM_MAX_CMDS_PER_TYPE> responseMsg{};
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
-    response.payload[1] = 1;
-    response.payload[2] = 2;
-    response.payload[3] = 3;
+    std::array<uint8_t, PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
+    responseMsg[1] = 1;
+    responseMsg[2] = 2;
+    responseMsg[3] = 3;
     std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> outTypes{};
     uint8_t completion_code;
 
-    auto rc =
-        decode_get_commands_resp(&response, &completion_code, outTypes.data());
+    auto rc = decode_get_commands_resp(responseMsg.data(), responseMsg.size(),
+                                       &completion_code, outTypes.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, PLDM_SUCCESS);
-    ASSERT_EQ(response.payload[1], outTypes[0].byte);
-    ASSERT_EQ(response.payload[2], outTypes[1].byte);
-    ASSERT_EQ(response.payload[3], outTypes[2].byte);
+    ASSERT_EQ(responseMsg[1], outTypes[0].byte);
+    ASSERT_EQ(responseMsg[2], outTypes[1].byte);
+    ASSERT_EQ(responseMsg[3], outTypes[2].byte);
 }
 
 TEST(GetPLDMVersion, testGoodEncodeRequest)
 {
-    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestMsg{};
-    pldm_msg request{};
-    request.body.payload = requestMsg.data();
-    request.body.payload_length = requestMsg.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES>
+        requestMsg{};
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
     uint8_t pldmType = 0x03;
     uint32_t transferHandle = 0x0;
     uint8_t opFlag = 0x01;
 
     auto rc =
-        encode_get_version_req(0, transferHandle, opFlag, pldmType, &request);
+        encode_get_version_req(0, transferHandle, opFlag, pldmType, request);
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(0, memcmp(request.body.payload, &transferHandle,
-                        sizeof(transferHandle)));
-    ASSERT_EQ(0, memcmp(request.body.payload + sizeof(transferHandle), &opFlag,
+    ASSERT_EQ(
+        0, memcmp(request->payload, &transferHandle, sizeof(transferHandle)));
+    ASSERT_EQ(0, memcmp(request->payload + sizeof(transferHandle), &opFlag,
                         sizeof(opFlag)));
-    ASSERT_EQ(0, memcmp(request.body.payload + sizeof(transferHandle) +
-                            sizeof(opFlag),
-                        &pldmType, sizeof(pldmType)));
+    ASSERT_EQ(0,
+              memcmp(request->payload + sizeof(transferHandle) + sizeof(opFlag),
+                     &pldmType, sizeof(pldmType)));
 }
 
 TEST(GetPLDMVersion, testBadEncodeRequest)
@@ -343,39 +336,32 @@
 
 TEST(GetPLDMVersion, testEncodeResponse)
 {
-    pldm_msg response{};
     uint8_t completionCode = 0;
     uint32_t transferHandle = 0;
     uint8_t flag = PLDM_START_AND_END;
-    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_RESP_BYTES>
+        responseMsg{};
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
     ver32_t version = {0xFF, 0xFF, 0xFF, 0xFF};
 
     auto rc = encode_get_version_resp(0, PLDM_SUCCESS, 0, PLDM_START_AND_END,
-                                      &version, sizeof(ver32_t), &response);
+                                      &version, sizeof(ver32_t), response);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(completionCode, response.body.payload[0]);
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]),
-                     &transferHandle, sizeof(transferHandle)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(transferHandle),
-                     &flag, sizeof(flag)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(transferHandle) + sizeof(flag),
-                     &version, sizeof(version)));
+    ASSERT_EQ(completionCode, response->payload[0]);
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
+                        &transferHandle, sizeof(transferHandle)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(transferHandle),
+                        &flag, sizeof(flag)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(transferHandle) + sizeof(flag),
+                        &version, sizeof(version)));
 }
 
 TEST(GetPLDMVersion, testDecodeRequest)
 {
     std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestMsg{};
-    pldm_msg_payload request{};
-    request.payload = requestMsg.data();
-    request.payload_length = requestMsg.size();
     uint32_t transferHandle = 0x0;
     uint32_t retTransferHandle = 0x0;
     uint8_t flag = PLDM_GET_FIRSTPART;
@@ -383,13 +369,13 @@
     uint8_t pldmType = PLDM_BASE;
     uint8_t retType = PLDM_BASE;
 
-    memcpy(request.payload, &transferHandle, sizeof(transferHandle));
-    memcpy(request.payload + sizeof(transferHandle), &flag, sizeof(flag));
-    memcpy(request.payload + sizeof(transferHandle) + sizeof(flag), &pldmType,
+    memcpy(requestMsg.data(), &transferHandle, sizeof(transferHandle));
+    memcpy(requestMsg.data() + sizeof(transferHandle), &flag, sizeof(flag));
+    memcpy(requestMsg.data() + sizeof(transferHandle) + sizeof(flag), &pldmType,
            sizeof(pldmType));
 
-    auto rc = decode_get_version_req(&request, &retTransferHandle, &retFlag,
-                                     &retType);
+    auto rc = decode_get_version_req(requestMsg.data(), requestMsg.size(),
+                                     &retTransferHandle, &retFlag, &retType);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(transferHandle, retTransferHandle);
@@ -400,9 +386,6 @@
 TEST(GetPLDMVersion, testDecodeResponse)
 {
     std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
     uint32_t transferHandle = 0x0;
     uint32_t retTransferHandle = 0x0;
     uint8_t flag = PLDM_START_AND_END;
@@ -412,16 +395,17 @@
     ver32_t versionOut;
     uint8_t completion_code;
 
-    memcpy(response.payload + sizeof(completionCode), &transferHandle,
+    memcpy(responseMsg.data() + sizeof(completionCode), &transferHandle,
            sizeof(transferHandle));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(transferHandle),
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(transferHandle),
            &flag, sizeof(flag));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(transferHandle) +
-               sizeof(flag),
+    memcpy(responseMsg.data() + sizeof(completionCode) +
+               sizeof(transferHandle) + sizeof(flag),
            &version, sizeof(version));
 
-    auto rc = decode_get_version_resp(
-        &response, &completion_code, &retTransferHandle, &retFlag, &versionOut);
+    auto rc = decode_get_version_resp(responseMsg.data(), responseMsg.size(),
+                                      &completion_code, &retTransferHandle,
+                                      &retFlag, &versionOut);
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(transferHandle, retTransferHandle);
     ASSERT_EQ(flag, retFlag);
diff --git a/test/libpldm_bios_test.cpp b/test/libpldm_bios_test.cpp
index b1771c9..3fde16a 100644
--- a/test/libpldm_bios_test.cpp
+++ b/test/libpldm_bios_test.cpp
@@ -10,8 +10,6 @@
 TEST(GetDateTime, testEncodeRequest)
 {
     pldm_msg request{};
-    request.body.payload = nullptr;
-    request.body.payload_length = 0;
 
     auto rc = encode_get_date_time_req(0, &request);
     ASSERT_EQ(rc, PLDM_SUCCESS);
@@ -27,49 +25,41 @@
     uint8_t month = 11;
     uint16_t year = 2019;
 
-    std::array<uint8_t, PLDM_GET_DATE_TIME_RESP_BYTES> responseMsg{};
-    pldm_msg response{};
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_DATE_TIME_RESP_BYTES>
+        responseMsg{};
 
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
 
     auto rc = encode_get_date_time_resp(0, PLDM_SUCCESS, seconds, minutes,
-                                        hours, day, month, year, &response);
+                                        hours, day, month, year, response);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(completionCode, response.body.payload[0]);
+    ASSERT_EQ(completionCode, response->payload[0]);
 
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]),
-                     &seconds, sizeof(seconds)));
-    ASSERT_EQ(0, memcmp(response.body.payload +
-                            sizeof(response.body.payload[0]) + sizeof(seconds),
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
+                        &seconds, sizeof(seconds)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(seconds),
                         &minutes, sizeof(minutes)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(seconds) + sizeof(minutes),
-                     &hours, sizeof(hours)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(seconds) + sizeof(minutes) + sizeof(hours),
-                     &day, sizeof(day)));
-    ASSERT_EQ(0, memcmp(response.body.payload +
-                            sizeof(response.body.payload[0]) + sizeof(seconds) +
-                            sizeof(minutes) + sizeof(hours) + sizeof(day),
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(seconds) + sizeof(minutes),
+                        &hours, sizeof(hours)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(seconds) + sizeof(minutes) + sizeof(hours),
+                        &day, sizeof(day)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(seconds) + sizeof(minutes) + sizeof(hours) +
+                            sizeof(day),
                         &month, sizeof(month)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(seconds) + sizeof(minutes) + sizeof(hours) +
-                         sizeof(day) + sizeof(month),
-                     &year, sizeof(year)));
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+                            sizeof(seconds) + sizeof(minutes) + sizeof(hours) +
+                            sizeof(day) + sizeof(month),
+                        &year, sizeof(year)));
 }
 
 TEST(GetDateTime, testDecodeResponse)
 {
     std::array<uint8_t, PLDM_GET_DATE_TIME_RESP_BYTES> responseMsg{};
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
 
     uint8_t completionCode = 0;
 
@@ -87,26 +77,26 @@
     uint8_t retMonth = 0;
     uint16_t retYear = 0;
 
-    memcpy(response.payload + sizeof(completionCode), &seconds,
+    memcpy(responseMsg.data() + sizeof(completionCode), &seconds,
            sizeof(seconds));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(seconds),
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds),
            &minutes, sizeof(minutes));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(seconds) +
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
                sizeof(minutes),
            &hours, sizeof(hours));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(seconds) +
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
                sizeof(minutes) + sizeof(hours),
            &day, sizeof(day));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(seconds) +
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
                sizeof(minutes) + sizeof(hours) + sizeof(day),
            &month, sizeof(month));
-    memcpy(response.payload + sizeof(completionCode) + sizeof(seconds) +
+    memcpy(responseMsg.data() + sizeof(completionCode) + sizeof(seconds) +
                sizeof(minutes) + sizeof(hours) + sizeof(day) + sizeof(month),
            &year, sizeof(year));
 
-    auto rc = decode_get_date_time_resp(&response, &completionCode, &retSeconds,
-                                        &retMinutes, &retHours, &retDay,
-                                        &retMonth, &retYear);
+    auto rc = decode_get_date_time_resp(
+        responseMsg.data(), responseMsg.size(), &completionCode, &retSeconds,
+        &retMinutes, &retHours, &retDay, &retMonth, &retYear);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(seconds, retSeconds);
diff --git a/test/libpldm_platform_test.cpp b/test/libpldm_platform_test.cpp
index 1e14b25..b046e3f 100644
--- a/test/libpldm_platform_test.cpp
+++ b/test/libpldm_platform_test.cpp
@@ -9,57 +9,49 @@
 
 TEST(SetStateEffecterStates, testEncodeResponse)
 {
-    pldm_msg response{};
+    std::array<uint8_t,
+               sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
+        responseMsg{};
+    auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
     uint8_t completionCode = 0;
 
-    std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
-        responseMsg{};
-
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-
-    auto rc = encode_set_state_effecter_states_resp(0, PLDM_SUCCESS, &response);
+    auto rc = encode_set_state_effecter_states_resp(0, PLDM_SUCCESS, response);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(completionCode, response.body.payload[0]);
+    ASSERT_EQ(completionCode, response->payload[0]);
 }
 
 TEST(SetStateEffecterStates, testEncodeRequest)
 {
-    pldm_msg request{};
+    std::array<uint8_t,
+               sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES>
+        requestMsg{};
+    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
     uint16_t effecterId = 0x0A;
     uint8_t compEffecterCnt = 0x2;
     std::array<set_effecter_state_field, 8> stateField{};
     stateField[0] = {PLDM_REQUEST_SET, 2};
     stateField[1] = {PLDM_REQUEST_SET, 3};
 
-    std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES> requestMsg{};
-
-    request.body.payload = requestMsg.data();
-    request.body.payload_length = requestMsg.size();
-
     auto rc = encode_set_state_effecter_states_req(
-        0, effecterId, compEffecterCnt, stateField.data(), &request);
+        0, effecterId, compEffecterCnt, stateField.data(), request);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
-    ASSERT_EQ(effecterId, request.body.payload[0]);
-    ASSERT_EQ(compEffecterCnt, request.body.payload[sizeof(effecterId)]);
-    ASSERT_EQ(
-        stateField[0].set_request,
-        request.body.payload[sizeof(effecterId) + sizeof(compEffecterCnt)]);
-    ASSERT_EQ(
-        stateField[0].effecter_state,
-        request.body.payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
-                             sizeof(stateField[0].set_request)]);
-    ASSERT_EQ(
-        stateField[1].set_request,
-        request.body.payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
-                             sizeof(stateField[0])]);
-    ASSERT_EQ(
-        stateField[1].effecter_state,
-        request.body.payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
-                             sizeof(stateField[0]) +
-                             sizeof(stateField[1].set_request)]);
+    ASSERT_EQ(effecterId, request->payload[0]);
+    ASSERT_EQ(compEffecterCnt, request->payload[sizeof(effecterId)]);
+    ASSERT_EQ(stateField[0].set_request,
+              request->payload[sizeof(effecterId) + sizeof(compEffecterCnt)]);
+    ASSERT_EQ(stateField[0].effecter_state,
+              request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
+                               sizeof(stateField[0].set_request)]);
+    ASSERT_EQ(stateField[1].set_request,
+              request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
+                               sizeof(stateField[0])]);
+    ASSERT_EQ(stateField[1].effecter_state,
+              request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
+                               sizeof(stateField[0]) +
+                               sizeof(stateField[1].set_request)]);
 }
 
 TEST(SetStateEffecterStates, testGoodDecodeResponse)
@@ -67,18 +59,14 @@
     std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
         responseMsg{};
 
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
-
     uint8_t completion_code = 0xA0;
 
     uint8_t retcompletion_code = 0;
 
-    memcpy(response.payload, &completion_code, sizeof(completion_code));
+    memcpy(responseMsg.data(), &completion_code, sizeof(completion_code));
 
-    auto rc =
-        decode_set_state_effecter_states_resp(&response, &retcompletion_code);
+    auto rc = decode_set_state_effecter_states_resp(
+        responseMsg.data(), responseMsg.size(), &retcompletion_code);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(completion_code, retcompletion_code);
@@ -88,10 +76,6 @@
 {
     std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES> requestMsg{};
 
-    pldm_msg_payload request{};
-    request.payload = requestMsg.data();
-    request.payload_length = requestMsg.size();
-
     uint16_t effecterId = 0x32;
     uint8_t compEffecterCnt = 0x2;
 
@@ -104,14 +88,15 @@
 
     std::array<set_effecter_state_field, 8> retStateField{};
 
-    memcpy(request.payload, &effecterId, sizeof(effecterId));
-    memcpy(request.payload + sizeof(effecterId), &compEffecterCnt,
+    memcpy(requestMsg.data(), &effecterId, sizeof(effecterId));
+    memcpy(requestMsg.data() + sizeof(effecterId), &compEffecterCnt,
            sizeof(compEffecterCnt));
-    memcpy(request.payload + sizeof(effecterId) + sizeof(compEffecterCnt),
+    memcpy(requestMsg.data() + sizeof(effecterId) + sizeof(compEffecterCnt),
            &stateField, sizeof(stateField));
 
     auto rc = decode_set_state_effecter_states_req(
-        &request, &retEffecterId, &retCompEffecterCnt, retStateField.data());
+        requestMsg.data(), requestMsg.size(), &retEffecterId,
+        &retCompEffecterCnt, retStateField.data());
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(effecterId, retEffecterId);
@@ -124,13 +109,10 @@
 
 TEST(SetStateEffecterStates, testBadDecodeRequest)
 {
-    std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES> requestMsg{};
+    const uint8_t* msg = NULL;
 
-    pldm_msg_payload request{};
-    request.payload = requestMsg.data();
-    request.payload_length = requestMsg.size();
-
-    auto rc = decode_set_state_effecter_states_req(&request, NULL, NULL, NULL);
+    auto rc = decode_set_state_effecter_states_req(msg, sizeof(*msg), NULL,
+                                                   NULL, NULL);
 
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 }
@@ -140,11 +122,8 @@
     std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
         responseMsg{};
 
-    pldm_msg_payload response{};
-    response.payload = responseMsg.data();
-    response.payload_length = responseMsg.size();
-
-    auto rc = decode_set_state_effecter_states_resp(&response, NULL);
+    auto rc = decode_set_state_effecter_states_resp(responseMsg.data(),
+                                                    responseMsg.size(), NULL);
 
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 }
diff --git a/test/libpldmresponder_base_test.cpp b/test/libpldmresponder_base_test.cpp
index cdd22e6..8990d22 100644
--- a/test/libpldmresponder_base_test.cpp
+++ b/test/libpldmresponder_base_test.cpp
@@ -12,62 +12,54 @@
 
 TEST(GetPLDMTypes, testGoodRequest)
 {
-    pldm_msg_payload request{};
-    pldm_msg response{};
-    std::array<uint8_t, PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-    getPLDMTypes(&request, &response);
+    std::array<uint8_t, sizeof(pldm_msg_hdr)> requestPayload{};
+    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    // payload length will be 0 in this case
+    size_t requestPayloadLength = 0;
+    auto response = getPLDMTypes(request, requestPayloadLength);
     // Only base type supported at the moment
-    ASSERT_EQ(response.body.payload[0], 0);
-    ASSERT_EQ(response.body.payload[1], 1);
-    ASSERT_EQ(response.body.payload[2], 0);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    uint8_t* payload_ptr = responsePtr->payload;
+    ASSERT_EQ(payload_ptr[0], 0);
+    ASSERT_EQ(payload_ptr[1], 1);
+    ASSERT_EQ(payload_ptr[2], 0);
 }
 
 TEST(GetPLDMCommands, testGoodRequest)
 {
     // Only base type supported at the moment, and commands -
     // GetPLDMTypes, GetPLDMCommands
-    pldm_msg response{};
-    std::array<uint8_t, PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-    pldm_msg_payload request{};
-    std::array<uint8_t, 5> requestPayload{};
-    request.payload = requestPayload.data();
-    request.payload_length = requestPayload.size();
-    getPLDMCommands(&request, &response);
-    ASSERT_EQ(response.body.payload[0], 0);
-    ASSERT_EQ(response.body.payload[1], 48); // 48 = 0b110000
-    ASSERT_EQ(response.body.payload[2], 0);
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES>
+        requestPayload{};
+    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
+    auto response = getPLDMCommands(request, requestPayloadLength);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    uint8_t* payload_ptr = responsePtr->payload;
+    ASSERT_EQ(payload_ptr[0], 0);
+    ASSERT_EQ(payload_ptr[1], 48); // 48 = 0b110000
+    ASSERT_EQ(payload_ptr[2], 0);
 }
 
 TEST(GetPLDMCommands, testBadRequest)
 {
-    pldm_msg response{};
-    std::array<uint8_t, PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-    pldm_msg_payload request{};
-    std::array<uint8_t, 5> requestPayload{};
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES>
+        requestPayload{};
+    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
 
-    request.payload = requestPayload.data();
-    request.payload[0] = 0xFF;
-    request.payload_length = requestPayload.size();
-    getPLDMCommands(&request, &response);
-    ASSERT_EQ(response.body.payload[0], PLDM_ERROR_INVALID_PLDM_TYPE);
+    request->payload[0] = 0xFF;
+    size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
+    auto response = getPLDMCommands(request, requestPayloadLength);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
+    uint8_t* payload_ptr = responsePtr->payload;
+    ASSERT_EQ(payload_ptr[0], PLDM_ERROR_INVALID_PLDM_TYPE);
 }
-
 TEST(GetPLDMVersion, testGoodRequest)
 {
-    pldm_msg response{};
-    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-    pldm_msg request{};
-    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestPayload{};
-    request.body.payload = requestPayload.data();
-    request.body.payload_length = requestPayload.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES>
+        requestPayload{};
+    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     uint8_t pldmType = PLDM_BASE;
     uint32_t transferHandle = 0x0;
@@ -76,61 +68,53 @@
     ver32_t version = {0xF1, 0xF0, 0xF0, 0x00};
 
     auto rc =
-        encode_get_version_req(0, transferHandle, flag, pldmType, &request);
+        encode_get_version_req(0, transferHandle, flag, pldmType, request);
 
     ASSERT_EQ(0, rc);
 
-    getPLDMVersion(&(request.body), &response);
+    auto response = getPLDMVersion(request, requestPayloadLength);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    ASSERT_EQ(response.body.payload[0], 0);
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]),
-                     &transferHandle, sizeof(transferHandle)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(transferHandle),
-                     &retFlag, sizeof(flag)));
-    ASSERT_EQ(0,
-              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
-                         sizeof(transferHandle) + sizeof(flag),
-                     &version, sizeof(version)));
+    ASSERT_EQ(responsePtr->payload[0], 0);
+    ASSERT_EQ(0, memcmp(responsePtr->payload + sizeof(responsePtr->payload[0]),
+                        &transferHandle, sizeof(transferHandle)));
+    ASSERT_EQ(0, memcmp(responsePtr->payload + sizeof(responsePtr->payload[0]) +
+                            sizeof(transferHandle),
+                        &retFlag, sizeof(flag)));
+    ASSERT_EQ(0, memcmp(responsePtr->payload + sizeof(responsePtr->payload[0]) +
+                            sizeof(transferHandle) + sizeof(flag),
+                        &version, sizeof(version)));
 }
-
 TEST(GetPLDMVersion, testBadRequest)
 {
-    pldm_msg response{};
-    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
-    response.body.payload = responseMsg.data();
-    response.body.payload_length = responseMsg.size();
-    pldm_msg request{};
-
-    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestPayload{};
-
-    std::array<uint8_t, (PLDM_GET_VERSION_REQ_BYTES - 3)> requestPayloadSmall{};
-    request.body.payload = requestPayloadSmall.data();
-    request.body.payload_length = requestPayloadSmall.size();
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES>
+        requestPayload{};
+    auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
     uint8_t pldmType = 7;
     uint32_t transferHandle = 0x0;
     uint8_t flag = PLDM_GET_FIRSTPART;
 
     auto rc =
-        encode_get_version_req(0, transferHandle, flag, pldmType, &request);
+        encode_get_version_req(0, transferHandle, flag, pldmType, request);
 
     ASSERT_EQ(0, rc);
 
-    getPLDMVersion(&(request.body), &response);
+    auto response = getPLDMVersion(request, requestPayloadLength - 1);
+    auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    ASSERT_EQ(response.body.payload[0], PLDM_ERROR_INVALID_LENGTH);
+    ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_LENGTH);
 
-    request.body.payload = requestPayload.data();
-    request.body.payload_length = requestPayload.size();
+    request = reinterpret_cast<pldm_msg*>(requestPayload.data());
+    requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
 
-    rc = encode_get_version_req(0, transferHandle, flag, pldmType, &request);
+    rc = encode_get_version_req(0, transferHandle, flag, pldmType, request);
 
     ASSERT_EQ(0, rc);
 
-    getPLDMVersion(&(request.body), &response);
+    response = getPLDMVersion(request, requestPayloadLength);
+    responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
-    ASSERT_EQ(response.body.payload[0], PLDM_ERROR_INVALID_PLDM_TYPE);
+    ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_PLDM_TYPE);
 }