PLDM Message Structure Change
With this change, PLDM code is optimised. The PLDM payload message
structure previously consisted of a pointer to the payload message and
the payload length, this structure is removed with this commit and the
PLDM message structure now has the PLDM header structure and an array of
size 1 whose address is the starting byte of message payload. Therefore,
pldm msg struct can represent a request/response message in contiguous
memory, thereby enabling simple casts and avoiding memcpys to get from a
uint8_t* to pldm msg or vice versa.
This commit also introduces a change to have the response handlers allocate
memory for responses. This is aligned with the message struct change, and
enables varying length responses.
Change-Id: Ia46d852b8b16bfc7cf04f38435bd4079ad33c66b
Signed-off-by: vkaverap <vkaverap@in.ibm.com>
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);
}