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