responder: Add PollForPlatformEventMessage APIs
Added APIs to encode/decode PollForPlatformEventMessage command(0x0B)
which is defined in DSP0248 Version 1.2.2 sec:16.7.
Signed-off-by: Dung Cao <dung@os.amperecomputing.com>
Signed-off-by: Thu Nguyen <thu@os.amperecomputing.com>
Change-Id: Ic4a91625c9e30b49a9a3ea99755dffff2c667ca8
diff --git a/include/libpldm/base.h b/include/libpldm/base.h
index e230482..bb160b3 100644
--- a/include/libpldm/base.h
+++ b/include/libpldm/base.h
@@ -51,6 +51,7 @@
enum transfer_op_flag {
PLDM_GET_NEXTPART = 0,
PLDM_GET_FIRSTPART = 1,
+ PLDM_ACKNOWLEDGEMENT_ONLY = 2,
};
enum transfer_multipart_op_flag {
diff --git a/include/libpldm/platform.h b/include/libpldm/platform.h
index 514dbe9..9149da2 100644
--- a/include/libpldm/platform.h
+++ b/include/libpldm/platform.h
@@ -37,6 +37,8 @@
#define PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES 8
#define PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES 4
+#define PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_RESP_BYTES 14
+#define PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_CHECKSUM_BYTES 4
/* Minimum response length */
#define PLDM_GET_PDR_MIN_RESP_BYTES 12
@@ -1600,6 +1602,21 @@
uint8_t *event_class,
size_t *event_data_offset);
+/** @brief Decode PollForEventMessage request data
+ * @param[in] msg - Request message
+ * @param[in] payload_length - Length of response message payload
+ * @param[out] format_version - Version of the event format
+ * @param[out] transfer_operation_flag - The transfer operation flag
+ * @param[out] data_transfer_handle - The data transfer handle
+ * @param[out] event_id_to_acknowledge - The class of event being sent
+ * from pldm msg
+ * @return pldm_completion_codes
+ */
+int decode_poll_for_platform_event_message_req(
+ const struct pldm_msg *msg, size_t payload_length, uint8_t *format_version,
+ uint8_t *transfer_operation_flag, uint32_t *data_transfer_handle,
+ uint16_t *event_id_to_acknowledge);
+
/** @brief Encode PlatformEventMessage response data
* @param[in] instance_id - Message's instance id
* @param[in] completion_code - PLDM completion code
@@ -1615,6 +1632,30 @@
uint8_t platform_event_status,
struct pldm_msg *msg);
+/** @brief Encode PollForPlatformEventMessage response data
+ * @param[in] instance_id - Message's instance id
+ * @param[in] completion_code - PLDM completion code
+ * @param[in] tid - Terminus ID
+ * @param[in] event_id - The event id
+ * @param[in] next_data_transfer_handle - The next data transfer handle
+ * @param[in] transfer_flag - The transfer flag
+ * @param[in] event_class - The event class
+ * @param[in] event_data_size - The event data size
+ * @param[in] event_data - The event data
+ * @param[in] checksum - The checksum
+ * @param[out] msg - Message will be written to this
+ * @param[in] payload_length - Length of Response message payload
+ * @return pldm_completion_codes
+ * @note Caller is responsible for memory alloc and dealloc of param
+ * 'msg.payload'
+ */
+int encode_poll_for_platform_event_message_resp(
+ uint8_t instance_id, uint8_t completion_code, uint8_t tid,
+ uint16_t event_id, uint32_t next_data_transfer_handle,
+ uint8_t transfer_flag, uint8_t event_class, uint32_t event_data_size,
+ uint8_t *event_data, uint32_t checksum, struct pldm_msg *msg,
+ size_t payload_length);
+
/** @brief Encode PlatformEventMessage request data
* @param[in] instance_id - Message's instance id
* @param[in] format_version - Version of the event format
diff --git a/src/platform.c b/src/platform.c
index eae38c1..7292847 100644
--- a/src/platform.c
+++ b/src/platform.c
@@ -886,6 +886,52 @@
return pldm_msgbuf_destroy(buf);
}
+int decode_poll_for_platform_event_message_req(
+ const struct pldm_msg *msg, size_t payload_length, uint8_t *format_version,
+ uint8_t *transfer_operation_flag, uint32_t *data_transfer_handle,
+ uint16_t *event_id_to_acknowledge)
+{
+ struct pldm_msgbuf _buf;
+ struct pldm_msgbuf *buf = &_buf;
+ int rc;
+
+ if (msg == NULL) {
+ return PLDM_ERROR_INVALID_DATA;
+ }
+
+ rc = pldm_msgbuf_init(buf,
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES,
+ msg->payload, payload_length);
+ if (rc) {
+ return rc;
+ }
+
+ pldm_msgbuf_extract(buf, format_version);
+ rc = pldm_msgbuf_extract(buf, transfer_operation_flag);
+ if (rc) {
+ return rc;
+ }
+ if (*transfer_operation_flag > PLDM_ACKNOWLEDGEMENT_ONLY) {
+ return PLDM_ERROR_INVALID_DATA;
+ }
+
+ pldm_msgbuf_extract(buf, data_transfer_handle);
+ rc = pldm_msgbuf_extract(buf, event_id_to_acknowledge);
+ if (rc) {
+ return rc;
+ }
+
+ if (!(((*transfer_operation_flag == PLDM_GET_NEXTPART) &&
+ (*event_id_to_acknowledge == 0xFFFF)) ||
+ ((*transfer_operation_flag == PLDM_GET_FIRSTPART) &&
+ (*event_id_to_acknowledge == 0x000)) ||
+ (*transfer_operation_flag == PLDM_ACKNOWLEDGEMENT_ONLY))) {
+ return PLDM_ERROR_INVALID_DATA;
+ }
+
+ return pldm_msgbuf_destroy(buf);
+}
+
int encode_platform_event_message_resp(uint8_t instance_id,
uint8_t completion_code,
uint8_t platform_event_status,
@@ -918,6 +964,71 @@
return PLDM_SUCCESS;
}
+int encode_poll_for_platform_event_message_resp(
+ uint8_t instance_id, uint8_t completion_code, uint8_t tid,
+ uint16_t event_id, uint32_t next_data_transfer_handle,
+ uint8_t transfer_flag, uint8_t event_class, uint32_t event_data_size,
+ uint8_t *event_data, uint32_t checksum, struct pldm_msg *msg,
+ size_t payload_length)
+{
+ struct pldm_msgbuf _buf;
+ struct pldm_msgbuf *buf = &_buf;
+ int rc;
+
+ if (!msg) {
+ return PLDM_ERROR_INVALID_DATA;
+ }
+
+ struct pldm_header_info header = {0};
+ header.msg_type = PLDM_RESPONSE;
+ header.instance = instance_id;
+ header.pldm_type = PLDM_PLATFORM;
+ header.command = PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE;
+
+ rc = pack_pldm_header(&header, &(msg->hdr));
+ if (rc != PLDM_SUCCESS) {
+ return rc;
+ }
+
+ rc = pldm_msgbuf_init(
+ buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
+ msg->payload, payload_length);
+ if (rc) {
+ return rc;
+ }
+
+ pldm_msgbuf_insert(buf, completion_code);
+ pldm_msgbuf_insert(buf, tid);
+ pldm_msgbuf_insert(buf, event_id);
+
+ if (event_id == 0xffff || event_id == 0x0000) {
+ if (PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES !=
+ payload_length) {
+ return PLDM_ERROR_INVALID_LENGTH;
+ }
+ return pldm_msgbuf_destroy(buf);
+ }
+
+ if ((event_data == NULL) && (event_data_size > 0)) {
+ return PLDM_ERROR_INVALID_DATA;
+ }
+
+ pldm_msgbuf_insert(buf, next_data_transfer_handle);
+ pldm_msgbuf_insert(buf, transfer_flag);
+ pldm_msgbuf_insert(buf, event_class);
+ pldm_msgbuf_insert(buf, event_data_size);
+
+ if ((event_data_size > 0) && event_data) {
+ pldm_msgbuf_insert_array(buf, event_data, event_data_size);
+ }
+
+ if (transfer_flag == PLDM_END || transfer_flag == PLDM_START_AND_END) {
+ pldm_msgbuf_insert(buf, checksum);
+ }
+
+ return pldm_msgbuf_destroy(buf);
+}
+
int encode_platform_event_message_req(
uint8_t instance_id, uint8_t format_version, uint8_t tid,
uint8_t event_class, const uint8_t *event_data, size_t event_data_length,
diff --git a/tests/libpldm_platform_test.cpp b/tests/libpldm_platform_test.cpp
index 7746b59..99b6729 100644
--- a/tests/libpldm_platform_test.cpp
+++ b/tests/libpldm_platform_test.cpp
@@ -1433,6 +1433,421 @@
EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
}
+TEST(PollForPlatformEventMessage, testGoodDecodeRequestFirstPart)
+{
+ uint8_t formatVersion = 0x1;
+ uint8_t transferOperationFlag = PLDM_GET_FIRSTPART;
+ uint32_t dataTransferHandle = 0x11223344;
+ uint16_t eventIdToAcknowledge = 0x0;
+ std::vector<uint8_t> requestMsg{0x1, 0x0, 0x0, 0x1, PLDM_GET_FIRSTPART,
+ 0x44, 0x33, 0x22, 0x11, 0x00,
+ 0x00};
+ auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
+ uint8_t retFormatVersion;
+ uint8_t retTransferOperationFlag;
+ uint32_t retDataTransferHandle;
+ uint16_t retEventIdToAcknowledge;
+
+ auto rc = decode_poll_for_platform_event_message_req(
+ request, requestMsg.size() - hdrSize, &retFormatVersion,
+ &retTransferOperationFlag, &retDataTransferHandle,
+ &retEventIdToAcknowledge);
+
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(retFormatVersion, formatVersion);
+ EXPECT_EQ(retTransferOperationFlag, transferOperationFlag);
+ EXPECT_EQ(retDataTransferHandle, dataTransferHandle);
+ EXPECT_EQ(retEventIdToAcknowledge, eventIdToAcknowledge);
+}
+
+TEST(PollForPlatformEventMessage, testGoodDecodeRequestNextPart)
+{
+ uint8_t formatVersion = 0x1;
+ uint8_t transferOperationFlag = PLDM_GET_NEXTPART;
+ uint32_t dataTransferHandle = 0x11223344;
+ uint16_t eventIdToAcknowledge = 0xffff;
+ std::vector<uint8_t> requestMsg{0x1, 0x0, 0x0, 0x1, PLDM_GET_NEXTPART,
+ 0x44, 0x33, 0x22, 0x11, 0xff,
+ 0xff};
+ auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
+ uint8_t retFormatVersion;
+ uint8_t retTransferOperationFlag;
+ uint32_t retDataTransferHandle;
+ uint16_t retEventIdToAcknowledge;
+
+ auto rc = decode_poll_for_platform_event_message_req(
+ request, requestMsg.size() - hdrSize, &retFormatVersion,
+ &retTransferOperationFlag, &retDataTransferHandle,
+ &retEventIdToAcknowledge);
+
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(retFormatVersion, formatVersion);
+ EXPECT_EQ(retTransferOperationFlag, transferOperationFlag);
+ EXPECT_EQ(retDataTransferHandle, dataTransferHandle);
+ EXPECT_EQ(retEventIdToAcknowledge, eventIdToAcknowledge);
+}
+
+TEST(PollForPlatformEventMessage, testGoodDecodeRequestAck)
+{
+ uint8_t formatVersion = 0x1;
+ uint8_t transferOperationFlag = PLDM_ACKNOWLEDGEMENT_ONLY;
+ uint32_t dataTransferHandle = 0x11223344;
+ uint16_t eventIdToAcknowledge = 0xffff;
+ std::vector<uint8_t> requestMsg{
+ 0x1, 0x0, 0x0, 0x1, PLDM_ACKNOWLEDGEMENT_ONLY, 0x44, 0x33,
+ 0x22, 0x11, 0xff, 0xff};
+ auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
+ uint8_t retFormatVersion;
+ uint8_t retTransferOperationFlag;
+ uint32_t retDataTransferHandle;
+ uint16_t retEventIdToAcknowledge;
+
+ auto rc = decode_poll_for_platform_event_message_req(
+ request, requestMsg.size() - hdrSize, &retFormatVersion,
+ &retTransferOperationFlag, &retDataTransferHandle,
+ &retEventIdToAcknowledge);
+
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(retFormatVersion, formatVersion);
+ EXPECT_EQ(retTransferOperationFlag, transferOperationFlag);
+ EXPECT_EQ(retDataTransferHandle, dataTransferHandle);
+ EXPECT_EQ(retEventIdToAcknowledge, eventIdToAcknowledge);
+}
+
+TEST(PollForPlatformEventMessage, testBadDecodeRequest)
+{
+ std::vector<uint8_t> requestMsg{0x1, 0x0, 0x0, 0x1, PLDM_GET_FIRSTPART,
+ 0x44, 0x33, 0x22, 0x11, 0x66,
+ 0x55};
+ auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
+ uint8_t retFormatVersion;
+ uint8_t retTransferOperationFlag;
+ uint32_t retDataTransferHandle;
+ uint16_t retEventIdToAcknowledge;
+
+ auto rc = decode_poll_for_platform_event_message_req(
+ NULL, requestMsg.size() - hdrSize, &retFormatVersion,
+ &retTransferOperationFlag, &retDataTransferHandle,
+ &retEventIdToAcknowledge);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+ /*
+ * transfer_operation_flag is not PLDM_GET_FIRSTPART or PLDM_GET_NEXTPART or
+ * PLDM_ACKNOWLEDGEMENT_ONLY
+ */
+
+ requestMsg[4] = PLDM_ACKNOWLEDGEMENT_ONLY + 1;
+
+ rc = decode_poll_for_platform_event_message_req(
+ request, requestMsg.size() - hdrSize, &retFormatVersion,
+ &retTransferOperationFlag, &retDataTransferHandle,
+ &retEventIdToAcknowledge);
+
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ /*
+ * transfer_operation_flag is PLDM_GET_FIRSTPART and
+ * event_id_to_acknowledge not 0x0000
+ */
+ requestMsg[4] = PLDM_GET_FIRSTPART;
+ requestMsg[9] = 0x0;
+ requestMsg[10] = 0x1;
+
+ rc = decode_poll_for_platform_event_message_req(
+ request, requestMsg.size() - hdrSize, &retFormatVersion,
+ &retTransferOperationFlag, &retDataTransferHandle,
+ &retEventIdToAcknowledge);
+
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+ /*
+ * transfer_operation_flag is not PLDM_GET_FIRSTPART and
+ * event_id_to_acknowledge is 0x0000
+ */
+ requestMsg[4] = PLDM_GET_NEXTPART;
+ requestMsg[9] = 0x0;
+ requestMsg[10] = 0x0;
+
+ rc = decode_poll_for_platform_event_message_req(
+ request, requestMsg.size() - hdrSize, &retFormatVersion,
+ &retTransferOperationFlag, &retDataTransferHandle,
+ &retEventIdToAcknowledge);
+
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+ /*
+ * transfer_operation_flag is PLDM_GET_NEXTPART and
+ * event_id_to_acknowledge not 0xffff
+ */
+ requestMsg[4] = PLDM_GET_NEXTPART;
+ requestMsg[9] = 0x0;
+ requestMsg[10] = 0x1;
+
+ rc = decode_poll_for_platform_event_message_req(
+ request, requestMsg.size() - hdrSize, &retFormatVersion,
+ &retTransferOperationFlag, &retDataTransferHandle,
+ &retEventIdToAcknowledge);
+
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+ /*
+ * transfer_operation_flag is not PLDM_GET_NEXTPART and
+ * event_id_to_acknowledge is 0xffff
+ */
+ requestMsg[4] = PLDM_GET_FIRSTPART;
+ requestMsg[9] = 0xff;
+ requestMsg[10] = 0xff;
+
+ rc = decode_poll_for_platform_event_message_req(
+ request, requestMsg.size() - hdrSize, &retFormatVersion,
+ &retTransferOperationFlag, &retDataTransferHandle,
+ &retEventIdToAcknowledge);
+
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+}
+
+TEST(PollForPlatformEventMessage, testGoodEncodeResposeP1)
+{
+ uint8_t completionCode = PLDM_SUCCESS;
+ uint8_t instance_id = 0;
+ uint8_t tId = 0x9;
+ uint16_t eventId = 0x1;
+ uint32_t nextDataTransferHandle = 0xffff;
+ uint8_t transferFlag = PLDM_END;
+ uint8_t eventClass = 0x5;
+ constexpr uint32_t eventDataSize = 9;
+ uint8_t pEventData[eventDataSize] = {0x31, 0x32, 0x33, 0x34, 0x35,
+ 0x36, 0x37, 0x38, 0x39};
+ uint32_t eventDataIntegrityChecksum = 0x11223344;
+ constexpr size_t payloadLength =
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_RESP_BYTES + eventDataSize + 4;
+
+ std::array<uint8_t, hdrSize + payloadLength> responseMsg{};
+ auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+ auto rc = encode_poll_for_platform_event_message_resp(
+ instance_id, completionCode, tId, eventId, nextDataTransferHandle,
+ transferFlag, eventClass, eventDataSize, pEventData,
+ eventDataIntegrityChecksum, response, payloadLength);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+
+ struct pldm_msgbuf _buf;
+ struct pldm_msgbuf* buf = &_buf;
+ rc = pldm_msgbuf_init(buf,
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
+ response->payload, payloadLength);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+
+ uint8_t retCompletionCode;
+ uint8_t retTid = 0;
+ uint16_t retEventId = 0;
+ uint32_t retNextDataTransferHandle = 0;
+ uint8_t retTransferFlag = 0;
+ uint8_t retEventClass = 0;
+ uint32_t retEventDataSize = 0;
+ uint8_t retEventData[payloadLength] = {0};
+ uint32_t retEventDataIntegrityChecksum = 0;
+
+ pldm_msgbuf_extract_uint8(buf, &retCompletionCode);
+ pldm_msgbuf_extract_uint8(buf, &retTid);
+ pldm_msgbuf_extract_uint16(buf, &retEventId);
+ pldm_msgbuf_extract_uint32(buf, &retNextDataTransferHandle);
+ pldm_msgbuf_extract_uint8(buf, &retTransferFlag);
+ pldm_msgbuf_extract_uint8(buf, &retEventClass);
+ pldm_msgbuf_extract_uint32(buf, &retEventDataSize);
+ pldm_msgbuf_extract_array_uint8(buf, retEventData, retEventDataSize);
+ pldm_msgbuf_extract_uint32(buf, &retEventDataIntegrityChecksum);
+
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(retCompletionCode, completionCode);
+ EXPECT_EQ(retTid, tId);
+ EXPECT_EQ(retEventId, eventId);
+ EXPECT_EQ(retNextDataTransferHandle, nextDataTransferHandle);
+ EXPECT_EQ(retTransferFlag, transferFlag);
+ EXPECT_EQ(retEventClass, eventClass);
+ EXPECT_EQ(retEventDataSize, eventDataSize);
+ EXPECT_EQ(retEventDataIntegrityChecksum, eventDataIntegrityChecksum);
+ EXPECT_EQ(0, memcmp(pEventData, retEventData, eventDataSize));
+
+ EXPECT_EQ(pldm_msgbuf_destroy(buf), PLDM_SUCCESS);
+}
+
+TEST(PollForPlatformEventMessage, testGoodEncodeResposeP2)
+{
+ uint8_t completionCode = PLDM_SUCCESS;
+ uint8_t instance_id = 0;
+ uint8_t tId = 0x9;
+ uint16_t eventId = 0x0000;
+ constexpr size_t payloadLength =
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES;
+
+ std::array<uint8_t, hdrSize + payloadLength> responseMsg{};
+ auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+ auto rc = encode_poll_for_platform_event_message_resp(
+ instance_id, completionCode, tId, eventId, 0, 0, 0, 0, NULL, 0,
+ response, payloadLength);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+
+ struct pldm_msgbuf _buf;
+ struct pldm_msgbuf* buf = &_buf;
+ rc = pldm_msgbuf_init(buf,
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
+ response->payload, payloadLength);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+
+ uint8_t retCompletionCode;
+ uint8_t retTid = 0;
+ uint16_t retEventId = 0;
+
+ pldm_msgbuf_extract_uint8(buf, &retCompletionCode);
+ pldm_msgbuf_extract_uint8(buf, &retTid);
+ pldm_msgbuf_extract_uint16(buf, &retEventId);
+
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(retCompletionCode, completionCode);
+ EXPECT_EQ(retTid, tId);
+ EXPECT_EQ(retEventId, eventId);
+ EXPECT_EQ(pldm_msgbuf_destroy(buf), PLDM_SUCCESS);
+}
+
+TEST(PollForPlatformEventMessage, testGoodEncodeResposeP3)
+{
+ uint8_t completionCode = PLDM_SUCCESS;
+ uint8_t instance_id = 0;
+ uint8_t tId = 0x9;
+ uint16_t eventId = 0xffff;
+ constexpr size_t payloadLength =
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES;
+
+ std::array<uint8_t, hdrSize + payloadLength> responseMsg{};
+ auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+ auto rc = encode_poll_for_platform_event_message_resp(
+ instance_id, completionCode, tId, eventId, 0, 0, 0, 0, NULL, 0,
+ response, payloadLength);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+
+ struct pldm_msgbuf _buf;
+ struct pldm_msgbuf* buf = &_buf;
+ rc = pldm_msgbuf_init(buf,
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
+ response->payload, payloadLength);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+
+ uint8_t retCompletionCode;
+ uint8_t retTid = 0;
+ uint16_t retEventId = 0;
+
+ pldm_msgbuf_extract_uint8(buf, &retCompletionCode);
+ pldm_msgbuf_extract_uint8(buf, &retTid);
+ pldm_msgbuf_extract_uint16(buf, &retEventId);
+
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(retCompletionCode, completionCode);
+ EXPECT_EQ(retTid, tId);
+ EXPECT_EQ(retEventId, eventId);
+ EXPECT_EQ(pldm_msgbuf_destroy(buf), PLDM_SUCCESS);
+}
+
+TEST(PollForPlatformEventMessage, testGoodEncodeResposeP4)
+{
+ uint8_t completionCode = PLDM_SUCCESS;
+ uint8_t instance_id = 0;
+ uint8_t tId = 0x9;
+ uint16_t eventId = 0x1;
+ uint32_t nextDataTransferHandle = 0xffff;
+ uint8_t transferFlag = PLDM_END;
+ uint8_t eventClass = 0x5;
+ constexpr uint32_t eventDataSize = 0;
+ uint32_t eventDataIntegrityChecksum = 0x11223344;
+ size_t payloadLength =
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_RESP_BYTES + eventDataSize + 4;
+
+ std::array<uint8_t, hdrSize +
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_RESP_BYTES +
+ eventDataSize + 4>
+ responseMsg{};
+ auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+ auto rc = encode_poll_for_platform_event_message_resp(
+ instance_id, completionCode, tId, eventId, nextDataTransferHandle,
+ transferFlag, eventClass, eventDataSize, NULL,
+ eventDataIntegrityChecksum, response, payloadLength);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+
+ struct pldm_msgbuf _buf;
+ struct pldm_msgbuf* buf = &_buf;
+ rc = pldm_msgbuf_init(buf,
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
+ response->payload, payloadLength);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+
+ uint8_t retCompletionCode;
+ uint8_t retTid = 0;
+ uint16_t retEventId = 0;
+ uint32_t retNextDataTransferHandle = 0;
+ uint8_t retTransferFlag = 0;
+ uint8_t retEventClass = 0;
+ uint32_t retEventDataSize = 0;
+ uint32_t retEventDataIntegrityChecksum = 0;
+
+ pldm_msgbuf_extract_uint8(buf, &retCompletionCode);
+ pldm_msgbuf_extract_uint8(buf, &retTid);
+ pldm_msgbuf_extract_uint16(buf, &retEventId);
+ pldm_msgbuf_extract_uint32(buf, &retNextDataTransferHandle);
+ pldm_msgbuf_extract_uint8(buf, &retTransferFlag);
+ pldm_msgbuf_extract_uint8(buf, &retEventClass);
+ pldm_msgbuf_extract_uint32(buf, &retEventDataSize);
+ pldm_msgbuf_extract_uint32(buf, &retEventDataIntegrityChecksum);
+
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(retCompletionCode, completionCode);
+ EXPECT_EQ(retTid, tId);
+ EXPECT_EQ(retEventId, eventId);
+ EXPECT_EQ(retNextDataTransferHandle, nextDataTransferHandle);
+ EXPECT_EQ(retTransferFlag, transferFlag);
+ EXPECT_EQ(retEventClass, eventClass);
+ EXPECT_EQ(retEventDataSize, eventDataSize);
+ EXPECT_EQ(retEventDataIntegrityChecksum, eventDataIntegrityChecksum);
+
+ EXPECT_EQ(pldm_msgbuf_destroy(buf), PLDM_SUCCESS);
+}
+
+TEST(PollForPlatformEventMessage, testBadEncodeResponse)
+{
+ uint8_t completionCode = PLDM_SUCCESS;
+ uint8_t instance_id = 0;
+ uint8_t tId = 0x9;
+ uint16_t eventId = 0x1;
+ uint32_t nextDataTransferHandle = 0xffff;
+ uint8_t transferFlag = 0x0;
+ uint8_t eventClass = 0x5;
+ const uint32_t eventDataSize = 0;
+ uint32_t eventDataIntegrityChecksum = 0x11223344;
+ constexpr size_t payloadLength =
+ PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_RESP_BYTES + eventDataSize + 4;
+
+ std::array<uint8_t, hdrSize + payloadLength> responseMsg{};
+ auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+ auto rc = encode_poll_for_platform_event_message_resp(
+ instance_id, completionCode, tId, eventId, nextDataTransferHandle,
+ transferFlag, eventClass, eventDataSize, NULL,
+ eventDataIntegrityChecksum, NULL, payloadLength);
+
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+
+ rc = encode_poll_for_platform_event_message_resp(
+ instance_id, completionCode, tId, eventId, nextDataTransferHandle,
+ transferFlag, eventClass, 1, NULL, eventDataIntegrityChecksum, response,
+ payloadLength);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+}
+
TEST(PlatformEventMessage, testGoodStateSensorDecodeRequest)
{
std::array<uint8_t,