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/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);
}