1 #include <libpldm/base.h> 2 #include <libpldm/pldm_types.h> 3 4 #include <array> 5 #include <cstdint> 6 #include <cstring> 7 #include <vector> 8 9 #include "msgbuf.h" 10 11 #include <gmock/gmock.h> 12 #include <gtest/gtest.h> 13 14 using testing::ElementsAreArray; 15 16 constexpr auto hdrSize = sizeof(pldm_msg_hdr); 17 18 TEST(PackPLDMMessage, BadPathTest) 19 { 20 struct pldm_header_info hdr; 21 struct pldm_header_info* hdr_ptr = NULL; 22 pldm_msg_hdr msg{}; 23 24 // PLDM header information pointer is NULL 25 auto rc = pack_pldm_header(hdr_ptr, &msg); 26 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 27 28 // PLDM message pointer is NULL 29 rc = pack_pldm_header(&hdr, nullptr); 30 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 31 32 // PLDM header information pointer and PLDM message pointer is NULL 33 rc = pack_pldm_header(hdr_ptr, nullptr); 34 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 35 36 // RESERVED message type 37 hdr.msg_type = PLDM_RESERVED; 38 rc = pack_pldm_header(&hdr, &msg); 39 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 40 41 // Instance ID out of range 42 hdr.msg_type = PLDM_REQUEST; 43 hdr.instance = 32; 44 rc = pack_pldm_header(&hdr, &msg); 45 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 46 47 // PLDM type out of range 48 hdr.msg_type = PLDM_REQUEST; 49 hdr.instance = 31; 50 hdr.pldm_type = 64; 51 rc = pack_pldm_header(&hdr, &msg); 52 EXPECT_EQ(rc, PLDM_ERROR_INVALID_PLDM_TYPE); 53 } 54 55 TEST(PackPLDMMessage, RequestMessageGoodPath) 56 { 57 struct pldm_header_info hdr; 58 pldm_msg_hdr msg{}; 59 60 // Message type is REQUEST and lower range of the field values 61 hdr.msg_type = PLDM_REQUEST; 62 hdr.instance = 0; 63 hdr.pldm_type = 0; 64 hdr.command = 0; 65 66 auto rc = pack_pldm_header(&hdr, &msg); 67 EXPECT_EQ(rc, PLDM_SUCCESS); 68 EXPECT_EQ(msg.request, 1); 69 EXPECT_EQ(msg.datagram, 0); 70 EXPECT_EQ(msg.instance_id, 0); 71 EXPECT_EQ(msg.type, 0); 72 EXPECT_EQ(msg.command, 0); 73 74 // Message type is REQUEST and upper range of the field values 75 hdr.instance = 31; 76 hdr.pldm_type = 63; 77 hdr.command = 255; 78 79 rc = pack_pldm_header(&hdr, &msg); 80 EXPECT_EQ(rc, PLDM_SUCCESS); 81 EXPECT_EQ(msg.request, 1); 82 EXPECT_EQ(msg.datagram, 0); 83 EXPECT_EQ(msg.instance_id, 31); 84 EXPECT_EQ(msg.type, 63); 85 EXPECT_EQ(msg.command, 255); 86 87 // Message type is PLDM_ASYNC_REQUEST_NOTIFY 88 hdr.msg_type = PLDM_ASYNC_REQUEST_NOTIFY; 89 90 rc = pack_pldm_header(&hdr, &msg); 91 EXPECT_EQ(rc, PLDM_SUCCESS); 92 EXPECT_EQ(msg.request, 1); 93 EXPECT_EQ(msg.datagram, 1); 94 EXPECT_EQ(msg.instance_id, 31); 95 EXPECT_EQ(msg.type, 63); 96 EXPECT_EQ(msg.command, 255); 97 } 98 99 TEST(PackPLDMMessage, ResponseMessageGoodPath) 100 { 101 struct pldm_header_info hdr; 102 pldm_msg_hdr msg{}; 103 104 // Message type is PLDM_RESPONSE and lower range of the field values 105 hdr.msg_type = PLDM_RESPONSE; 106 hdr.instance = 0; 107 hdr.pldm_type = 0; 108 hdr.command = 0; 109 110 auto rc = pack_pldm_header(&hdr, &msg); 111 EXPECT_EQ(rc, PLDM_SUCCESS); 112 EXPECT_EQ(msg.request, 0); 113 EXPECT_EQ(msg.datagram, 0); 114 EXPECT_EQ(msg.instance_id, 0); 115 EXPECT_EQ(msg.type, 0); 116 EXPECT_EQ(msg.command, 0); 117 118 // Message type is PLDM_RESPONSE and upper range of the field values 119 hdr.instance = 31; 120 hdr.pldm_type = 63; 121 hdr.command = 255; 122 123 rc = pack_pldm_header(&hdr, &msg); 124 EXPECT_EQ(rc, PLDM_SUCCESS); 125 EXPECT_EQ(msg.request, 0); 126 EXPECT_EQ(msg.datagram, 0); 127 EXPECT_EQ(msg.instance_id, 31); 128 EXPECT_EQ(msg.type, 63); 129 EXPECT_EQ(msg.command, 255); 130 } 131 132 TEST(UnpackPLDMMessage, BadPathTest) 133 { 134 struct pldm_header_info hdr; 135 136 // PLDM message pointer is NULL 137 auto rc = unpack_pldm_header(nullptr, &hdr); 138 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 139 } 140 141 TEST(UnpackPLDMMessage, RequestMessageGoodPath) 142 { 143 struct pldm_header_info hdr; 144 pldm_msg_hdr msg{}; 145 146 // Unpack PLDM request message and lower range of field values 147 msg.request = 1; 148 auto rc = unpack_pldm_header(&msg, &hdr); 149 EXPECT_EQ(rc, PLDM_SUCCESS); 150 EXPECT_EQ(hdr.msg_type, PLDM_REQUEST); 151 EXPECT_EQ(hdr.instance, 0); 152 EXPECT_EQ(hdr.pldm_type, 0); 153 EXPECT_EQ(hdr.command, 0); 154 155 // Unpack PLDM async request message and lower range of field values 156 msg.datagram = 1; 157 rc = unpack_pldm_header(&msg, &hdr); 158 EXPECT_EQ(rc, PLDM_SUCCESS); 159 EXPECT_EQ(hdr.msg_type, PLDM_ASYNC_REQUEST_NOTIFY); 160 161 // Unpack PLDM request message and upper range of field values 162 msg.datagram = 0; 163 msg.instance_id = 31; 164 msg.type = 63; 165 msg.command = 255; 166 rc = unpack_pldm_header(&msg, &hdr); 167 EXPECT_EQ(rc, PLDM_SUCCESS); 168 EXPECT_EQ(hdr.msg_type, PLDM_REQUEST); 169 EXPECT_EQ(hdr.instance, 31); 170 EXPECT_EQ(hdr.pldm_type, 63); 171 EXPECT_EQ(hdr.command, 255); 172 } 173 174 TEST(UnpackPLDMMessage, ResponseMessageGoodPath) 175 { 176 struct pldm_header_info hdr; 177 pldm_msg_hdr msg{}; 178 179 // Unpack PLDM response message and lower range of field values 180 auto rc = unpack_pldm_header(&msg, &hdr); 181 EXPECT_EQ(rc, PLDM_SUCCESS); 182 EXPECT_EQ(hdr.msg_type, PLDM_RESPONSE); 183 EXPECT_EQ(hdr.instance, 0); 184 EXPECT_EQ(hdr.pldm_type, 0); 185 EXPECT_EQ(hdr.command, 0); 186 187 // Unpack PLDM response message and upper range of field values 188 msg.instance_id = 31; 189 msg.type = 63; 190 msg.command = 255; 191 rc = unpack_pldm_header(&msg, &hdr); 192 EXPECT_EQ(rc, PLDM_SUCCESS); 193 EXPECT_EQ(hdr.msg_type, PLDM_RESPONSE); 194 EXPECT_EQ(hdr.instance, 31); 195 EXPECT_EQ(hdr.pldm_type, 63); 196 EXPECT_EQ(hdr.command, 255); 197 } 198 199 TEST(GetPLDMCommands, testEncodeRequest) 200 { 201 uint8_t pldmType = 0x05; 202 ver32_t version{0xff, 0xff, 0xff, 0xff}; 203 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_REQ_BYTES> 204 requestMsg{}; 205 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 206 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 207 208 auto rc = encode_get_commands_req(0, pldmType, version, request); 209 EXPECT_EQ(rc, PLDM_SUCCESS); 210 EXPECT_EQ(0, memcmp(request->payload, &pldmType, sizeof(pldmType))); 211 EXPECT_EQ(0, memcmp(request->payload + sizeof(pldmType), &version, 212 sizeof(version))); 213 } 214 215 TEST(GetPLDMCommands, testDecodeRequest) 216 { 217 uint8_t pldmType = 0x05; 218 ver32_t version{0xff, 0xff, 0xff, 0xff}; 219 uint8_t pldmTypeOut{}; 220 ver32_t versionOut{0xff, 0xff, 0xff, 0xff}; 221 std::array<uint8_t, hdrSize + PLDM_GET_COMMANDS_REQ_BYTES> requestMsg{}; 222 223 memcpy(requestMsg.data() + hdrSize, &pldmType, sizeof(pldmType)); 224 memcpy(requestMsg.data() + sizeof(pldmType) + hdrSize, &version, 225 sizeof(version)); 226 227 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 228 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 229 auto rc = decode_get_commands_req(request, requestMsg.size() - hdrSize, 230 &pldmTypeOut, &versionOut); 231 232 EXPECT_EQ(rc, PLDM_SUCCESS); 233 EXPECT_EQ(pldmTypeOut, pldmType); 234 EXPECT_EQ(0, memcmp(&versionOut, &version, sizeof(version))); 235 } 236 237 TEST(GetPLDMCommands, testEncodeResponse) 238 { 239 uint8_t completionCode = 0; 240 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_COMMANDS_RESP_BYTES> 241 responseMsg{}; 242 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 243 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 244 std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> commands{}; 245 commands[0].byte = 1; 246 commands[1].byte = 2; 247 commands[2].byte = 3; 248 249 auto rc = 250 encode_get_commands_resp(0, PLDM_SUCCESS, commands.data(), response); 251 EXPECT_EQ(rc, PLDM_SUCCESS); 252 uint8_t* payload_ptr = response->payload; 253 EXPECT_EQ(completionCode, payload_ptr[0]); 254 EXPECT_EQ(1, payload_ptr[sizeof(completionCode)]); 255 EXPECT_EQ(2, 256 payload_ptr[sizeof(completionCode) + sizeof(commands[0].byte)]); 257 EXPECT_EQ(3, payload_ptr[sizeof(completionCode) + sizeof(commands[0].byte) + 258 sizeof(commands[1].byte)]); 259 } 260 261 TEST(GetPLDMTypes, testEncodeResponse) 262 { 263 uint8_t completionCode = 0; 264 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_TYPES_RESP_BYTES> 265 responseMsg{}; 266 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 267 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 268 std::array<bitfield8_t, PLDM_MAX_TYPES / 8> types{}; 269 types[0].byte = 1; 270 types[1].byte = 2; 271 types[2].byte = 3; 272 273 auto rc = encode_get_types_resp(0, PLDM_SUCCESS, types.data(), response); 274 EXPECT_EQ(rc, PLDM_SUCCESS); 275 uint8_t* payload_ptr = response->payload; 276 EXPECT_EQ(completionCode, payload_ptr[0]); 277 EXPECT_EQ(1, payload_ptr[sizeof(completionCode)]); 278 EXPECT_EQ(2, payload_ptr[sizeof(completionCode) + sizeof(types[0].byte)]); 279 EXPECT_EQ(3, payload_ptr[sizeof(completionCode) + sizeof(types[0].byte) + 280 sizeof(types[1].byte)]); 281 } 282 283 TEST(GetPLDMTypes, testGoodDecodeResponse) 284 { 285 std::array<uint8_t, hdrSize + PLDM_GET_TYPES_RESP_BYTES> responseMsg{}; 286 responseMsg[1 + hdrSize] = 1; 287 responseMsg[2 + hdrSize] = 2; 288 responseMsg[3 + hdrSize] = 3; 289 std::array<bitfield8_t, PLDM_MAX_TYPES / 8> outTypes{}; 290 291 uint8_t completion_code; 292 responseMsg[hdrSize] = PLDM_SUCCESS; 293 294 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 295 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 296 297 auto rc = decode_get_types_resp(response, responseMsg.size() - hdrSize, 298 &completion_code, outTypes.data()); 299 300 EXPECT_EQ(rc, PLDM_SUCCESS); 301 EXPECT_EQ(completion_code, PLDM_SUCCESS); 302 EXPECT_EQ(responseMsg[1 + hdrSize], outTypes[0].byte); 303 EXPECT_EQ(responseMsg[2 + hdrSize], outTypes[1].byte); 304 EXPECT_EQ(responseMsg[3 + hdrSize], outTypes[2].byte); 305 } 306 307 TEST(GetPLDMTypes, testBadDecodeResponse) 308 { 309 std::array<uint8_t, hdrSize + PLDM_GET_TYPES_RESP_BYTES> responseMsg{}; 310 responseMsg[1 + hdrSize] = 1; 311 responseMsg[2 + hdrSize] = 2; 312 responseMsg[3 + hdrSize] = 3; 313 std::array<bitfield8_t, PLDM_MAX_TYPES / 8> outTypes{}; 314 315 uint8_t retcompletion_code = 0; 316 responseMsg[hdrSize] = PLDM_SUCCESS; 317 318 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 319 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 320 321 auto rc = decode_get_types_resp(response, responseMsg.size() - hdrSize - 1, 322 &retcompletion_code, outTypes.data()); 323 324 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH); 325 } 326 327 TEST(GetPLDMCommands, testGoodDecodeResponse) 328 { 329 std::array<uint8_t, hdrSize + PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{}; 330 responseMsg[1 + hdrSize] = 1; 331 responseMsg[2 + hdrSize] = 2; 332 responseMsg[3 + hdrSize] = 3; 333 std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> outTypes{}; 334 335 uint8_t completion_code; 336 responseMsg[hdrSize] = PLDM_SUCCESS; 337 338 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 339 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 340 341 auto rc = decode_get_commands_resp(response, responseMsg.size() - hdrSize, 342 &completion_code, outTypes.data()); 343 344 EXPECT_EQ(rc, PLDM_SUCCESS); 345 EXPECT_EQ(completion_code, PLDM_SUCCESS); 346 EXPECT_EQ(responseMsg[1 + hdrSize], outTypes[0].byte); 347 EXPECT_EQ(responseMsg[2 + hdrSize], outTypes[1].byte); 348 EXPECT_EQ(responseMsg[3 + hdrSize], outTypes[2].byte); 349 } 350 351 TEST(GetPLDMCommands, testBadDecodeResponse) 352 { 353 std::array<uint8_t, hdrSize + PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{}; 354 responseMsg[1 + hdrSize] = 1; 355 responseMsg[2 + hdrSize] = 2; 356 responseMsg[3 + hdrSize] = 3; 357 std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> outTypes{}; 358 359 uint8_t retcompletion_code = 0; 360 responseMsg[hdrSize] = PLDM_SUCCESS; 361 362 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 363 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 364 365 auto rc = 366 decode_get_commands_resp(response, responseMsg.size() - hdrSize - 1, 367 &retcompletion_code, outTypes.data()); 368 369 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH); 370 } 371 372 TEST(GetPLDMVersion, testGoodEncodeRequest) 373 { 374 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_REQ_BYTES> 375 requestMsg{}; 376 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 377 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 378 uint8_t pldmType = 0x03; 379 uint32_t transferHandle = 0x0; 380 uint8_t opFlag = 0x01; 381 382 auto rc = 383 encode_get_version_req(0, transferHandle, opFlag, pldmType, request); 384 EXPECT_EQ(rc, PLDM_SUCCESS); 385 EXPECT_EQ( 386 0, memcmp(request->payload, &transferHandle, sizeof(transferHandle))); 387 EXPECT_EQ(0, memcmp(request->payload + sizeof(transferHandle), &opFlag, 388 sizeof(opFlag))); 389 EXPECT_EQ(0, 390 memcmp(request->payload + sizeof(transferHandle) + sizeof(opFlag), 391 &pldmType, sizeof(pldmType))); 392 } 393 394 TEST(GetPLDMVersion, testBadEncodeRequest) 395 { 396 uint8_t pldmType = 0x03; 397 uint32_t transferHandle = 0x0; 398 uint8_t opFlag = 0x01; 399 400 auto rc = 401 encode_get_version_req(0, transferHandle, opFlag, pldmType, nullptr); 402 403 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 404 } 405 406 TEST(GetPLDMVersion, testEncodeResponse) 407 { 408 uint8_t completionCode = 0; 409 uint32_t transferHandle = 0; 410 uint8_t flag = PLDM_START_AND_END; 411 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_RESP_BYTES> 412 responseMsg{}; 413 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 414 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 415 ver32_t version = {0xff, 0xff, 0xff, 0xff}; 416 417 auto rc = encode_get_version_resp(0, PLDM_SUCCESS, 0, PLDM_START_AND_END, 418 &version, sizeof(ver32_t), response); 419 420 EXPECT_EQ(rc, PLDM_SUCCESS); 421 EXPECT_EQ(completionCode, response->payload[0]); 422 EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]), 423 &transferHandle, sizeof(transferHandle))); 424 EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) + 425 sizeof(transferHandle), 426 &flag, sizeof(flag))); 427 EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) + 428 sizeof(transferHandle) + sizeof(flag), 429 &version, sizeof(version))); 430 } 431 432 TEST(GetPLDMVersion, testDecodeRequest) 433 { 434 std::array<uint8_t, hdrSize + PLDM_GET_VERSION_REQ_BYTES> requestMsg{}; 435 uint32_t transferHandle = 0x0; 436 uint32_t retTransferHandle = 0x0; 437 uint8_t flag = PLDM_GET_FIRSTPART; 438 uint8_t retFlag = PLDM_GET_FIRSTPART; 439 uint8_t pldmType = PLDM_BASE; 440 uint8_t retType = PLDM_BASE; 441 442 memcpy(requestMsg.data() + hdrSize, &transferHandle, 443 sizeof(transferHandle)); 444 memcpy(requestMsg.data() + sizeof(transferHandle) + hdrSize, &flag, 445 sizeof(flag)); 446 memcpy(requestMsg.data() + sizeof(transferHandle) + sizeof(flag) + hdrSize, 447 &pldmType, sizeof(pldmType)); 448 449 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 450 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 451 452 auto rc = decode_get_version_req(request, requestMsg.size() - hdrSize, 453 &retTransferHandle, &retFlag, &retType); 454 455 EXPECT_EQ(rc, PLDM_SUCCESS); 456 EXPECT_EQ(transferHandle, retTransferHandle); 457 EXPECT_EQ(flag, retFlag); 458 EXPECT_EQ(pldmType, retType); 459 } 460 461 TEST(GetPLDMVersion, testDecodeResponse) 462 { 463 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_VERSION_RESP_BYTES> 464 responseMsg{}; 465 uint32_t transferHandle = 0x0; 466 uint32_t retTransferHandle = 0x0; 467 uint8_t flag = PLDM_START_AND_END; 468 uint8_t retFlag = PLDM_START_AND_END; 469 uint8_t completionCode = 0; 470 ver32_t version = {0xff, 0xff, 0xff, 0xff}; 471 ver32_t versionOut; 472 uint8_t completion_code; 473 474 memcpy(responseMsg.data() + sizeof(completionCode) + hdrSize, 475 &transferHandle, sizeof(transferHandle)); 476 memcpy(responseMsg.data() + sizeof(completionCode) + 477 sizeof(transferHandle) + hdrSize, 478 &flag, sizeof(flag)); 479 memcpy(responseMsg.data() + sizeof(completionCode) + 480 sizeof(transferHandle) + sizeof(flag) + hdrSize, 481 &version, sizeof(version)); 482 483 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 484 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 485 486 auto rc = decode_get_version_resp(response, responseMsg.size() - hdrSize, 487 &completion_code, &retTransferHandle, 488 &retFlag, &versionOut); 489 EXPECT_EQ(rc, PLDM_SUCCESS); 490 EXPECT_EQ(transferHandle, retTransferHandle); 491 EXPECT_EQ(flag, retFlag); 492 493 EXPECT_EQ(versionOut.major, version.major); 494 EXPECT_EQ(versionOut.minor, version.minor); 495 EXPECT_EQ(versionOut.update, version.update); 496 EXPECT_EQ(versionOut.alpha, version.alpha); 497 } 498 499 TEST(GetTID, testEncodeRequest) 500 { 501 pldm_msg request{}; 502 503 auto rc = encode_get_tid_req(0, &request); 504 ASSERT_EQ(rc, PLDM_SUCCESS); 505 } 506 507 TEST(GetTID, testEncodeResponse) 508 { 509 uint8_t completionCode = 0; 510 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_TID_RESP_BYTES> 511 responseMsg{}; 512 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 513 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 514 uint8_t tid = 1; 515 516 auto rc = encode_get_tid_resp(0, PLDM_SUCCESS, tid, response); 517 EXPECT_EQ(rc, PLDM_SUCCESS); 518 uint8_t* payload = response->payload; 519 EXPECT_EQ(completionCode, payload[0]); 520 EXPECT_EQ(1, payload[sizeof(completionCode)]); 521 } 522 523 TEST(GetTID, testDecodeResponse) 524 { 525 std::array<uint8_t, hdrSize + PLDM_GET_TID_RESP_BYTES> responseMsg{}; 526 responseMsg[1 + hdrSize] = 1; 527 528 uint8_t tid; 529 uint8_t completion_code; 530 responseMsg[hdrSize] = PLDM_SUCCESS; 531 532 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 533 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 534 535 auto rc = decode_get_tid_resp(response, responseMsg.size() - hdrSize, 536 &completion_code, &tid); 537 538 EXPECT_EQ(rc, PLDM_SUCCESS); 539 EXPECT_EQ(completion_code, PLDM_SUCCESS); 540 EXPECT_EQ(tid, 1); 541 } 542 543 TEST(MultipartReceive, testDecodeRequestPass) 544 { 545 constexpr uint8_t kPldmType = PLDM_BASE; 546 constexpr uint8_t kFlag = PLDM_XFER_FIRST_PART; 547 constexpr uint32_t kTransferCtx = 0x01; 548 constexpr uint32_t kTransferHandle = 0x10; 549 constexpr uint32_t kSectionOffset = 0x0; 550 constexpr uint32_t kSectionLength = 0x10; 551 uint8_t pldm_type = 0x0; 552 uint8_t flag = PLDM_GET_FIRSTPART; 553 uint32_t transfer_ctx; 554 uint32_t transfer_handle; 555 uint32_t section_offset; 556 uint32_t section_length; 557 558 // Header values don't matter for this test. 559 pldm_msg_hdr hdr{}; 560 // Assign values to the packet struct and memcpy to ensure correct byte 561 // ordering. 562 pldm_multipart_receive_req req_pkt = { 563 .pldm_type = kPldmType, 564 .transfer_opflag = kFlag, 565 .transfer_ctx = kTransferCtx, 566 .transfer_handle = kTransferHandle, 567 .section_offset = kSectionOffset, 568 .section_length = kSectionLength, 569 }; 570 std::vector<uint8_t> req(sizeof(hdr) + PLDM_MULTIPART_RECEIVE_REQ_BYTES); 571 std::memcpy(req.data(), &hdr, sizeof(hdr)); 572 std::memcpy(req.data() + sizeof(hdr), &req_pkt, sizeof(req_pkt)); 573 574 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 575 pldm_msg* pldm_request = reinterpret_cast<pldm_msg*>(req.data()); 576 int rc = decode_multipart_receive_req( 577 pldm_request, req.size() - hdrSize, &pldm_type, &flag, &transfer_ctx, 578 &transfer_handle, §ion_offset, §ion_length); 579 580 EXPECT_EQ(rc, PLDM_SUCCESS); 581 EXPECT_EQ(pldm_type, kPldmType); 582 EXPECT_EQ(flag, kFlag); 583 EXPECT_EQ(transfer_ctx, kTransferCtx); 584 EXPECT_EQ(transfer_handle, kTransferHandle); 585 EXPECT_EQ(section_offset, kSectionOffset); 586 EXPECT_EQ(section_length, kSectionLength); 587 } 588 589 TEST(MultipartReceive, testDecodeRequestFailNullData) 590 { 591 EXPECT_EQ(decode_multipart_receive_req(NULL, 0, NULL, NULL, NULL, NULL, 592 NULL, NULL), 593 PLDM_ERROR_INVALID_DATA); 594 } 595 596 TEST(MultipartReceive, testDecodeRequestFailBadLength) 597 { 598 constexpr uint8_t kPldmType = PLDM_BASE; 599 constexpr uint8_t kFlag = PLDM_XFER_FIRST_PART; 600 uint8_t pldm_type; 601 uint8_t flag; 602 uint32_t transfer_ctx; 603 uint32_t transfer_handle; 604 uint32_t section_offset; 605 uint32_t section_length; 606 607 // Header values don't matter for this test. 608 pldm_msg_hdr hdr{}; 609 // Assign values to the packet struct and memcpy to ensure correct byte 610 // ordering. 611 pldm_multipart_receive_req req_pkt{}; 612 req_pkt.pldm_type = kPldmType; 613 req_pkt.transfer_opflag = kFlag; 614 615 std::vector<uint8_t> req(sizeof(hdr) + PLDM_MULTIPART_RECEIVE_REQ_BYTES); 616 std::memcpy(req.data(), &hdr, sizeof(hdr)); 617 std::memcpy(req.data() + sizeof(hdr), &req_pkt, sizeof(req_pkt)); 618 619 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 620 pldm_msg* pldm_request = reinterpret_cast<pldm_msg*>(req.data()); 621 EXPECT_EQ(decode_multipart_receive_req( 622 pldm_request, (req.size() - hdrSize) + 1, &pldm_type, &flag, 623 &transfer_ctx, &transfer_handle, §ion_offset, 624 §ion_length), 625 PLDM_ERROR_INVALID_LENGTH); 626 } 627 628 TEST(MultipartReceive, testDecodeRequestFailBadPldmType) 629 { 630 constexpr uint8_t kPldmType = 0xff; 631 constexpr uint8_t kFlag = PLDM_XFER_FIRST_PART; 632 uint8_t pldm_type; 633 uint8_t flag; 634 uint32_t transfer_ctx; 635 uint32_t transfer_handle; 636 uint32_t section_offset; 637 uint32_t section_length; 638 639 // Header values don't matter for this test. 640 pldm_msg_hdr hdr{}; 641 // Assign values to the packet struct and memcpy to ensure correct byte 642 // ordering. 643 pldm_multipart_receive_req req_pkt{}; 644 req_pkt.pldm_type = kPldmType; 645 req_pkt.transfer_opflag = kFlag; 646 647 std::vector<uint8_t> req(sizeof(hdr) + PLDM_MULTIPART_RECEIVE_REQ_BYTES); 648 std::memcpy(req.data(), &hdr, sizeof(hdr)); 649 std::memcpy(req.data() + sizeof(hdr), &req_pkt, sizeof(req_pkt)); 650 651 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 652 pldm_msg* pldm_request = reinterpret_cast<pldm_msg*>(req.data()); 653 EXPECT_EQ(decode_multipart_receive_req(pldm_request, req.size() - hdrSize, 654 &pldm_type, &flag, &transfer_ctx, 655 &transfer_handle, §ion_offset, 656 §ion_length), 657 PLDM_ERROR_INVALID_PLDM_TYPE); 658 } 659 660 TEST(MultipartReceive, testDecodeRequestFailBadTransferFlag) 661 { 662 constexpr uint8_t kPldmType = PLDM_BASE; 663 constexpr uint8_t kFlag = PLDM_XFER_CURRENT_PART + 0x10; 664 uint8_t pldm_type; 665 uint8_t flag; 666 uint32_t transfer_ctx; 667 uint32_t transfer_handle; 668 uint32_t section_offset; 669 uint32_t section_length; 670 671 // Header values don't matter for this test. 672 pldm_msg_hdr hdr{}; 673 // Assign values to the packet struct and memcpy to ensure correct byte 674 // ordering. 675 pldm_multipart_receive_req req_pkt{}; 676 req_pkt.pldm_type = kPldmType; 677 req_pkt.transfer_opflag = kFlag; 678 679 std::vector<uint8_t> req(sizeof(hdr) + PLDM_MULTIPART_RECEIVE_REQ_BYTES); 680 std::memcpy(req.data(), &hdr, sizeof(hdr)); 681 std::memcpy(req.data() + sizeof(hdr), &req_pkt, sizeof(req_pkt)); 682 683 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 684 pldm_msg* pldm_request = reinterpret_cast<pldm_msg*>(req.data()); 685 EXPECT_EQ(decode_multipart_receive_req(pldm_request, req.size() - hdrSize, 686 &pldm_type, &flag, &transfer_ctx, 687 &transfer_handle, §ion_offset, 688 §ion_length), 689 PLDM_ERROR_UNEXPECTED_TRANSFER_FLAG_OPERATION); 690 } 691 692 TEST(MultipartReceive, testDecodeRequestFailBadOffset) 693 { 694 constexpr uint8_t kPldmType = PLDM_BASE; 695 constexpr uint8_t kFlag = PLDM_XFER_NEXT_PART; 696 constexpr uint32_t kTransferHandle = 0x01; 697 constexpr uint32_t kSectionOffset = 0x0; 698 uint8_t pldm_type; 699 uint8_t flag; 700 uint32_t transfer_ctx; 701 uint32_t transfer_handle; 702 uint32_t section_offset; 703 uint32_t section_length; 704 705 // Header values don't matter for this test. 706 pldm_msg_hdr hdr{}; 707 // Assign values to the packet struct and memcpy to ensure correct byte 708 // ordering. 709 pldm_multipart_receive_req req_pkt{}; 710 req_pkt.pldm_type = kPldmType; 711 req_pkt.transfer_opflag = kFlag; 712 req_pkt.transfer_handle = kTransferHandle; 713 req_pkt.section_offset = kSectionOffset; 714 715 std::vector<uint8_t> req(sizeof(hdr) + PLDM_MULTIPART_RECEIVE_REQ_BYTES); 716 std::memcpy(req.data(), &hdr, sizeof(hdr)); 717 std::memcpy(req.data() + sizeof(hdr), &req_pkt, sizeof(req_pkt)); 718 719 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 720 pldm_msg* pldm_request = reinterpret_cast<pldm_msg*>(req.data()); 721 EXPECT_EQ(decode_multipart_receive_req(pldm_request, req.size() - hdrSize, 722 &pldm_type, &flag, &transfer_ctx, 723 &transfer_handle, §ion_offset, 724 §ion_length), 725 PLDM_ERROR_INVALID_DATA); 726 } 727 728 TEST(MultipartReceive, testDecodeRequestFailBadHandle) 729 { 730 constexpr uint8_t kPldmType = PLDM_BASE; 731 constexpr uint8_t kFlag = PLDM_XFER_NEXT_PART; 732 constexpr uint32_t kSectionOffset = 0x100; 733 constexpr uint32_t kTransferHandle = 0x0; 734 uint8_t pldm_type; 735 uint8_t flag; 736 uint32_t transfer_ctx; 737 uint32_t transfer_handle; 738 uint32_t section_offset; 739 uint32_t section_length; 740 741 // Header values don't matter for this test. 742 pldm_msg_hdr hdr{}; 743 // Assign values to the packet struct and memcpy to ensure correct byte 744 // ordering. 745 pldm_multipart_receive_req req_pkt{}; 746 req_pkt.pldm_type = kPldmType; 747 req_pkt.transfer_opflag = kFlag; 748 req_pkt.transfer_handle = kTransferHandle; 749 req_pkt.section_offset = kSectionOffset; 750 751 std::vector<uint8_t> req(sizeof(hdr) + PLDM_MULTIPART_RECEIVE_REQ_BYTES); 752 std::memcpy(req.data(), &hdr, sizeof(hdr)); 753 std::memcpy(req.data() + sizeof(hdr), &req_pkt, sizeof(req_pkt)); 754 755 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 756 pldm_msg* pldm_request = reinterpret_cast<pldm_msg*>(req.data()); 757 EXPECT_EQ(decode_multipart_receive_req(pldm_request, req.size() - hdrSize, 758 &pldm_type, &flag, &transfer_ctx, 759 &transfer_handle, §ion_offset, 760 §ion_length), 761 PLDM_ERROR_INVALID_DATA); 762 } 763 764 #ifdef LIBPLDM_API_TESTING 765 TEST(EncodeMultipartReceiveRequest, GoodTest) 766 { 767 uint8_t instance_id = 0; 768 769 const struct pldm_multipart_receive_req req_data = { 770 PLDM_BASE, PLDM_XFER_FIRST_PART, 0x01, 0x10, 0x00, 0x10}; 771 772 std::array<uint8_t, PLDM_MULTIPART_RECEIVE_REQ_BYTES> requestMsg = { 773 PLDM_BASE, PLDM_XFER_FIRST_PART, 774 0x01, 0x00, 775 0x00, 0x00, 776 0x10, 0x00, 777 0x00, 0x00, 778 0x00, 0x00, 779 0x00, 0x00, 780 0x10, 0x00, 781 0x00, 0x00}; 782 783 PLDM_MSG_DEFINE_P(requestPtr, PLDM_MULTIPART_RECEIVE_REQ_BYTES); 784 auto rc = encode_base_multipart_receive_req( 785 instance_id, &req_data, requestPtr, PLDM_MULTIPART_RECEIVE_REQ_BYTES); 786 787 ASSERT_EQ(rc, 0); 788 EXPECT_EQ( 789 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg))); 790 } 791 #endif 792 793 #ifdef LIBPLDM_API_TESTING 794 TEST(EncodeMultipartReceiveRequest, BadTestUnAllocatedPtrParams) 795 { 796 uint8_t instance_id = 0; 797 int rc; 798 799 const struct pldm_multipart_receive_req req_data = { 800 PLDM_BASE, PLDM_XFER_FIRST_PART, 0x01, 0x10, 0x00, 0x10}; 801 802 PLDM_MSG_DEFINE_P(requestPtr, PLDM_MULTIPART_RECEIVE_REQ_BYTES); 803 rc = encode_base_multipart_receive_req(instance_id, nullptr, requestPtr, 804 PLDM_MULTIPART_RECEIVE_REQ_BYTES); 805 EXPECT_EQ(rc, -EINVAL); 806 807 rc = encode_base_multipart_receive_req(instance_id, &req_data, nullptr, 808 PLDM_MULTIPART_RECEIVE_REQ_BYTES); 809 EXPECT_EQ(rc, -EINVAL); 810 } 811 #endif 812 813 #ifdef LIBPLDM_API_TESTING 814 TEST(EncodeMultipartReceiveRequest, BadTestInvalidExpectedOutputMsgLength) 815 { 816 uint8_t instance_id = 0; 817 int rc; 818 819 const struct pldm_multipart_receive_req req_data = { 820 PLDM_BASE, PLDM_XFER_FIRST_PART, 0x01, 0x10, 0x00, 0x10}; 821 822 PLDM_MSG_DEFINE_P(requestPtr, PLDM_MULTIPART_RECEIVE_REQ_BYTES); 823 824 rc = encode_base_multipart_receive_req(instance_id, &req_data, requestPtr, 825 1); 826 EXPECT_EQ(rc, -EOVERFLOW); 827 } 828 #endif 829 830 #ifdef LIBPLDM_API_TESTING 831 TEST(DecodeMultipartReceiveResponse, GoodTest) 832 { 833 uint8_t completionCode = PLDM_SUCCESS; 834 uint8_t transferFlag = PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_END; 835 uint32_t nextDataTransferHandle = 0x15; 836 static constexpr const uint32_t dataLength = 9; 837 std::vector<uint8_t> data = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 838 uint32_t dataIntegrityChecksum = 0x3C; 839 840 struct pldm_multipart_receive_resp resp_data = {}; 841 842 PLDM_MSGBUF_DEFINE_P(buf); 843 int rc; 844 845 static constexpr const size_t payload_length = 846 PLDM_BASE_MULTIPART_RECEIVE_RESP_MIN_BYTES + dataLength + 847 sizeof(dataIntegrityChecksum); 848 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 849 850 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 851 ASSERT_EQ(rc, 0); 852 853 pldm_msgbuf_insert_uint8(buf, completionCode); 854 pldm_msgbuf_insert_uint8(buf, transferFlag); 855 pldm_msgbuf_insert_uint32(buf, nextDataTransferHandle); 856 pldm_msgbuf_insert_uint32(buf, dataLength); 857 rc = pldm_msgbuf_insert_array_uint8(buf, dataLength, data.data(), 858 dataLength); 859 EXPECT_EQ(rc, 0); 860 pldm_msgbuf_insert_uint32(buf, dataIntegrityChecksum); 861 862 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 863 864 uint32_t respDataIntegrityChecksum = 0; 865 866 rc = decode_base_multipart_receive_resp( 867 responseMsg, payload_length, &resp_data, &respDataIntegrityChecksum); 868 869 ASSERT_EQ(rc, 0); 870 EXPECT_EQ(resp_data.completion_code, completionCode); 871 EXPECT_EQ(resp_data.transfer_flag, transferFlag); 872 EXPECT_EQ(resp_data.next_transfer_handle, nextDataTransferHandle); 873 EXPECT_EQ(resp_data.data.length, dataLength); 874 EXPECT_EQ(0, 875 memcmp(data.data(), resp_data.data.ptr, resp_data.data.length)); 876 EXPECT_EQ(respDataIntegrityChecksum, dataIntegrityChecksum); 877 } 878 #endif 879 880 #ifdef LIBPLDM_API_TESTING 881 TEST(DecodeMultipartReceiveResponse, BadTestUnAllocatedPtrParams) 882 { 883 uint8_t completionCode = PLDM_SUCCESS; 884 uint8_t transferFlag = PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_END; 885 uint32_t nextDataTransferHandle = 0x15; 886 static constexpr const uint32_t dataLength = 9; 887 std::vector<uint8_t> data = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 888 uint32_t dataIntegrityChecksum = 0x3C; 889 890 struct pldm_multipart_receive_resp resp_data = {}; 891 892 PLDM_MSGBUF_DEFINE_P(buf); 893 int rc; 894 895 static constexpr const size_t payload_length = 896 PLDM_BASE_MULTIPART_RECEIVE_RESP_MIN_BYTES + dataLength + 897 sizeof(dataIntegrityChecksum); 898 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 899 900 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 901 ASSERT_EQ(rc, 0); 902 903 pldm_msgbuf_insert_uint8(buf, completionCode); 904 pldm_msgbuf_insert_uint8(buf, transferFlag); 905 pldm_msgbuf_insert_uint32(buf, nextDataTransferHandle); 906 pldm_msgbuf_insert_uint32(buf, dataLength); 907 rc = pldm_msgbuf_insert_array_uint8(buf, dataLength, data.data(), 908 dataLength); 909 EXPECT_EQ(rc, 0); 910 pldm_msgbuf_insert_uint32(buf, dataIntegrityChecksum); 911 912 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 913 914 uint32_t respDataIntegrityChecksum = 0; 915 916 rc = decode_base_multipart_receive_resp(nullptr, payload_length, &resp_data, 917 &respDataIntegrityChecksum); 918 919 EXPECT_EQ(rc, -EINVAL); 920 921 rc = decode_base_multipart_receive_resp( 922 responseMsg, payload_length, nullptr, &respDataIntegrityChecksum); 923 924 EXPECT_EQ(rc, -EINVAL); 925 } 926 #endif 927 928 #ifdef LIBPLDM_API_TESTING 929 TEST(DecodeMultipartReceiveResponse, BadTestInvalidExpectedInputMsgLength) 930 { 931 uint8_t completionCode = PLDM_SUCCESS; 932 uint8_t transferFlag = PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_END; 933 uint32_t nextDataTransferHandle = 0x15; 934 static constexpr const uint32_t dataLength = 9; 935 std::vector<uint8_t> data = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 936 uint32_t dataIntegrityChecksum = 0x3C; 937 938 struct pldm_multipart_receive_resp resp_data = {}; 939 940 PLDM_MSGBUF_DEFINE_P(buf); 941 int rc; 942 943 static constexpr const size_t payload_length = 944 PLDM_BASE_MULTIPART_RECEIVE_RESP_MIN_BYTES + dataLength + 945 sizeof(dataIntegrityChecksum); 946 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 947 948 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 949 ASSERT_EQ(rc, 0); 950 951 pldm_msgbuf_insert_uint8(buf, completionCode); 952 pldm_msgbuf_insert_uint8(buf, transferFlag); 953 pldm_msgbuf_insert_uint32(buf, nextDataTransferHandle); 954 pldm_msgbuf_insert_uint32(buf, dataLength); 955 rc = pldm_msgbuf_insert_array_uint8(buf, dataLength, data.data(), 956 dataLength); 957 EXPECT_EQ(rc, 0); 958 pldm_msgbuf_insert_uint32(buf, dataIntegrityChecksum); 959 960 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 961 962 uint32_t respDataIntegrityChecksum = 0; 963 964 rc = decode_base_multipart_receive_resp(responseMsg, 0, &resp_data, 965 &respDataIntegrityChecksum); 966 967 EXPECT_EQ(rc, -EOVERFLOW); 968 } 969 #endif 970 971 #ifdef LIBPLDM_API_TESTING 972 TEST(EncodeMultipartReceiveResponse, GoodTestWithChecksum) 973 { 974 uint8_t instance_id = 0; 975 uint8_t completionCode = PLDM_SUCCESS; 976 uint8_t transferFlag = 977 PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_START_AND_END; 978 uint32_t nextDataTransferHandle = 0x15; 979 static constexpr const uint32_t dataLength = 9; 980 std::vector<uint8_t> data = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 981 uint32_t dataIntegrityChecksum = 0x3C; 982 static constexpr const size_t responseMsgLength = 983 PLDM_BASE_MULTIPART_RECEIVE_RESP_MIN_BYTES + dataLength + 984 sizeof(dataIntegrityChecksum); 985 size_t payload_length = responseMsgLength; 986 987 struct variable_field payload = {data.data(), dataLength}; 988 struct pldm_multipart_receive_resp resp_data = { 989 completionCode, transferFlag, nextDataTransferHandle, payload}; 990 std::array<uint8_t, responseMsgLength> responseMsg = { 991 completionCode, 992 transferFlag, 993 0x15, // nextDataTransferHandle 994 0x00, 995 0x00, 996 0x00, 997 0x09, // dataLength 998 0x00, 999 0x00, 1000 0x00, 1001 0x1, // data 1002 0x2, 1003 0x3, 1004 0x4, 1005 0x5, 1006 0x6, 1007 0x7, 1008 0x8, 1009 0x9, 1010 0x3c, // dataIntegrityChecksum 1011 0x00, 1012 0x00, 1013 0x00}; 1014 1015 PLDM_MSG_DEFINE_P(responsePtr, responseMsgLength); 1016 int rc; 1017 1018 rc = encode_base_multipart_receive_resp(instance_id, &resp_data, 1019 dataIntegrityChecksum, responsePtr, 1020 &payload_length); 1021 1022 ASSERT_EQ(0, rc); 1023 EXPECT_EQ(0, memcmp(responsePtr->payload, responseMsg.data(), 1024 sizeof(responseMsg))); 1025 EXPECT_EQ(payload_length, responseMsgLength); 1026 } 1027 #endif 1028 1029 #ifdef LIBPLDM_API_TESTING 1030 TEST(EncodeMultipartReceiveResponse, GoodTestWithoutChecksum) 1031 { 1032 uint8_t instance_id = 0; 1033 uint8_t completionCode = PLDM_SUCCESS; 1034 uint8_t transferFlag = PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_START; 1035 uint32_t nextDataTransferHandle = 0x16; 1036 static constexpr const uint32_t dataLength = 9; 1037 std::vector<uint8_t> data = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 1038 static constexpr const size_t responseMsgLength = 1039 PLDM_BASE_MULTIPART_RECEIVE_RESP_MIN_BYTES + dataLength; 1040 size_t payload_length = responseMsgLength; 1041 1042 struct variable_field payload = {data.data(), dataLength}; 1043 struct pldm_multipart_receive_resp resp_data = { 1044 completionCode, transferFlag, nextDataTransferHandle, payload}; 1045 std::array<uint8_t, responseMsgLength> responseMsg = { 1046 completionCode, 1047 transferFlag, 1048 0x16, // nextDataTransferHandle 1049 0x00, 1050 0x00, 1051 0x00, 1052 0x09, // dataLength 1053 0x00, 1054 0x00, 1055 0x00, 1056 0x1, // data 1057 0x2, 1058 0x3, 1059 0x4, 1060 0x5, 1061 0x6, 1062 0x7, 1063 0x8, 1064 0x9}; 1065 1066 PLDM_MSG_DEFINE_P(responsePtr, responseMsgLength); 1067 int rc; 1068 1069 rc = encode_base_multipart_receive_resp(instance_id, &resp_data, 0, 1070 responsePtr, &payload_length); 1071 1072 ASSERT_EQ(0, rc); 1073 EXPECT_EQ(0, memcmp(responsePtr->payload, responseMsg.data(), 1074 sizeof(responseMsg))); 1075 EXPECT_EQ(payload_length, responseMsgLength); 1076 } 1077 #endif 1078 1079 #ifdef LIBPLDM_API_TESTING 1080 TEST(EncodeMultipartReceiveResponse, GoodTestCompletionCode) 1081 { 1082 uint8_t instance_id = 0; 1083 uint8_t completionCode = PLDM_MULTIPART_RECEIVE_NEGOTIATION_INCOMPLETE; 1084 uint8_t transferFlag = PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_START; 1085 uint32_t nextDataTransferHandle = 0x16; 1086 static constexpr const uint32_t dataLength = 9; 1087 std::vector<uint8_t> data = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 1088 static constexpr const size_t responseMsgLength = 1089 PLDM_BASE_MULTIPART_RECEIVE_RESP_MIN_BYTES + dataLength; 1090 size_t payload_length = responseMsgLength; 1091 1092 struct variable_field payload = {data.data(), dataLength}; 1093 struct pldm_multipart_receive_resp resp_data = { 1094 completionCode, transferFlag, nextDataTransferHandle, payload}; 1095 std::array<uint8_t, 1> responseMsg = {completionCode}; 1096 1097 PLDM_MSG_DEFINE_P(responsePtr, responseMsgLength); 1098 int rc; 1099 1100 rc = encode_base_multipart_receive_resp(instance_id, &resp_data, 0, 1101 responsePtr, &payload_length); 1102 1103 ASSERT_EQ(0, rc); 1104 EXPECT_EQ(0, memcmp(responsePtr->payload, responseMsg.data(), 1105 sizeof(responseMsg))); 1106 EXPECT_EQ(payload_length, 1); 1107 } 1108 #endif 1109 1110 #ifdef LIBPLDM_API_TESTING 1111 TEST(EncodeMultipartReceiveResponse, BadTestUnAllocatedParams) 1112 { 1113 uint8_t instance_id = 0; 1114 uint8_t completionCode = PLDM_SUCCESS; 1115 uint8_t transferFlag = 1116 PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_START_AND_END; 1117 uint32_t nextDataTransferHandle = 0x15; 1118 static constexpr const uint32_t dataLength = 9; 1119 std::vector<uint8_t> data = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 1120 uint32_t dataIntegrityChecksum = 0x3C; 1121 static constexpr const size_t responseMsgLength = 1122 PLDM_BASE_MULTIPART_RECEIVE_RESP_MIN_BYTES + dataLength + 1123 sizeof(dataIntegrityChecksum); 1124 size_t payload_length = responseMsgLength; 1125 1126 struct variable_field payload = {data.data(), dataLength}; 1127 struct pldm_multipart_receive_resp resp_data = { 1128 completionCode, transferFlag, nextDataTransferHandle, payload}; 1129 1130 PLDM_MSG_DEFINE_P(responsePtr, responseMsgLength); 1131 int rc; 1132 1133 rc = encode_base_multipart_receive_resp(instance_id, nullptr, 1134 dataIntegrityChecksum, responsePtr, 1135 &payload_length); 1136 EXPECT_EQ(rc, -EINVAL); 1137 1138 rc = encode_base_multipart_receive_resp(instance_id, &resp_data, 1139 dataIntegrityChecksum, nullptr, 1140 &payload_length); 1141 EXPECT_EQ(rc, -EINVAL); 1142 1143 rc = encode_base_multipart_receive_resp( 1144 instance_id, &resp_data, dataIntegrityChecksum, responsePtr, nullptr); 1145 EXPECT_EQ(rc, -EINVAL); 1146 1147 resp_data.data.ptr = nullptr; 1148 rc = encode_base_multipart_receive_resp(instance_id, &resp_data, 1149 dataIntegrityChecksum, responsePtr, 1150 &payload_length); 1151 EXPECT_EQ(rc, -EINVAL); 1152 } 1153 #endif 1154 1155 #ifdef LIBPLDM_API_TESTING 1156 TEST(EncodeMultipartReceiveResponse, BadTestInvalidExpectedOutputMsgLength) 1157 { 1158 uint8_t instance_id = 0; 1159 uint8_t completionCode = PLDM_SUCCESS; 1160 uint8_t transferFlag = PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_START; 1161 uint32_t nextDataTransferHandle = 0x16; 1162 static constexpr const uint32_t dataLength = 9; 1163 std::vector<uint8_t> data = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 1164 static constexpr const size_t responseMsgLength = 1165 PLDM_BASE_MULTIPART_RECEIVE_RESP_MIN_BYTES; 1166 size_t payload_length = responseMsgLength; 1167 1168 struct variable_field payload = {data.data(), dataLength}; 1169 struct pldm_multipart_receive_resp resp_data = { 1170 completionCode, transferFlag, nextDataTransferHandle, payload}; 1171 1172 PLDM_MSG_DEFINE_P(responsePtr, responseMsgLength); 1173 int rc; 1174 1175 rc = encode_base_multipart_receive_resp(instance_id, &resp_data, 0, 1176 responsePtr, &payload_length); 1177 EXPECT_EQ(rc, -EOVERFLOW); 1178 } 1179 #endif 1180 1181 TEST(CcOnlyResponse, testEncode) 1182 { 1183 struct pldm_msg responseMsg; 1184 1185 auto rc = 1186 encode_cc_only_resp(0 /*instance id*/, 1 /*pldm type*/, 2 /*command*/, 1187 3 /*completion code*/, &responseMsg); 1188 EXPECT_EQ(rc, PLDM_SUCCESS); 1189 1190 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1191 auto p = reinterpret_cast<uint8_t*>(&responseMsg); 1192 EXPECT_THAT(std::vector<uint8_t>(p, p + sizeof(responseMsg)), 1193 ElementsAreArray({0, 1, 2, 3})); 1194 1195 rc = encode_cc_only_resp(PLDM_INSTANCE_MAX + 1, 1, 2, 3, &responseMsg); 1196 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 1197 1198 rc = encode_cc_only_resp(0, 1, 2, 3, nullptr); 1199 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 1200 } 1201 1202 TEST(SetTID, testGoodEncodeRequest) 1203 { 1204 uint8_t instanceId = 0; 1205 uint8_t tid = 0x01; 1206 std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(tid)> requestMsg{}; 1207 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1208 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 1209 1210 auto rc = encode_set_tid_req(instanceId, tid, request); 1211 ASSERT_EQ(rc, PLDM_SUCCESS); 1212 1213 EXPECT_EQ(request->hdr.command, PLDM_SET_TID); 1214 EXPECT_EQ(request->hdr.type, PLDM_BASE); 1215 EXPECT_EQ(request->hdr.request, 1); 1216 EXPECT_EQ(request->hdr.datagram, 0); 1217 EXPECT_EQ(request->hdr.instance_id, instanceId); 1218 EXPECT_EQ(0, memcmp(request->payload, &tid, sizeof(tid))); 1219 } 1220 1221 TEST(SetTID, testBadEncodeRequest) 1222 { 1223 uint8_t tid = 0x01; 1224 std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(tid)> requestMsg{}; 1225 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1226 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 1227 1228 auto rc = encode_set_tid_req(0, tid, nullptr); 1229 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 1230 1231 rc = encode_set_tid_req(0, 0, request); 1232 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 1233 1234 rc = encode_set_tid_req(0, 0xff, request); 1235 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 1236 } 1237 1238 #ifdef LIBPLDM_API_TESTING 1239 TEST(SetTID, testGoodDecodeRequest) 1240 { 1241 uint8_t tid = 0x01; 1242 uint8_t tidOut = 0x00; 1243 std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(tid)> requestMsg{}; 1244 1245 requestMsg[sizeof(pldm_msg_hdr)] = tid; 1246 1247 pldm_msg* request = new (requestMsg.data()) pldm_msg; 1248 auto rc = decode_set_tid_req( 1249 request, requestMsg.size() - sizeof(pldm_msg_hdr), &tidOut); 1250 1251 EXPECT_EQ(rc, PLDM_SUCCESS); 1252 EXPECT_EQ(tid, tidOut); 1253 } 1254 #endif 1255 1256 #ifdef LIBPLDM_API_TESTING 1257 TEST(SetTID, testBadDecodeRequestMsg) 1258 { 1259 uint8_t tid = 0x01; 1260 std::array<uint8_t, hdrSize + PLDM_SET_TID_REQ_BYTES> requestMsg{}; 1261 1262 auto rc = decode_set_tid_req( 1263 nullptr, requestMsg.size() - sizeof(pldm_msg_hdr), &tid); 1264 1265 EXPECT_EQ(rc, -EINVAL); 1266 } 1267 #endif 1268 1269 #ifdef LIBPLDM_API_TESTING 1270 TEST(SetTID, testBadDecodeRequestTid) 1271 { 1272 std::array<uint8_t, hdrSize + PLDM_SET_TID_REQ_BYTES> requestMsg{}; 1273 pldm_msg* request = new (requestMsg.data()) pldm_msg; 1274 1275 auto rc = decode_set_tid_req( 1276 request, requestMsg.size() - sizeof(pldm_msg_hdr), nullptr); 1277 1278 EXPECT_EQ(rc, -EINVAL); 1279 } 1280 #endif 1281 1282 #ifdef LIBPLDM_API_TESTING 1283 TEST(SetTID, testBadDecodeRequestMsgSize) 1284 { 1285 std::array<uint8_t, hdrSize + PLDM_SET_TID_REQ_BYTES> requestMsg{}; 1286 pldm_msg* request = new (requestMsg.data()) pldm_msg; 1287 1288 auto rc = decode_set_tid_req(request, -1, nullptr); 1289 1290 EXPECT_EQ(rc, -EINVAL); 1291 } 1292 #endif 1293 1294 #ifdef LIBPLDM_API_TESTING 1295 TEST(PldmMsgHdr, correlateSuccess) 1296 { 1297 static const struct pldm_msg_hdr req = { 1298 .instance_id = 0, 1299 .reserved = 0, 1300 .datagram = 0, 1301 .request = 1, 1302 .type = 0, 1303 .header_ver = 1, 1304 .command = 0x01, 1305 }; 1306 static const struct pldm_msg_hdr resp = { 1307 .instance_id = 0, 1308 .reserved = 0, 1309 .datagram = 0, 1310 .request = 0, 1311 .type = 0, 1312 .header_ver = 1, 1313 .command = 0x01, 1314 }; 1315 1316 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), true); 1317 } 1318 #endif 1319 1320 #ifdef LIBPLDM_API_TESTING 1321 TEST(PldmMsgHdr, correlateFailInstanceID) 1322 { 1323 static const struct pldm_msg_hdr req = { 1324 .instance_id = 0, 1325 .reserved = 0, 1326 .datagram = 0, 1327 .request = 1, 1328 .type = 0, 1329 .header_ver = 1, 1330 .command = 0x01, 1331 }; 1332 static const struct pldm_msg_hdr resp = { 1333 .instance_id = 1, 1334 .reserved = 0, 1335 .datagram = 0, 1336 .request = 0, 1337 .type = 0, 1338 .header_ver = 1, 1339 .command = 0x01, 1340 }; 1341 1342 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), false); 1343 } 1344 #endif 1345 1346 #ifdef LIBPLDM_API_TESTING 1347 TEST(PldmMsgHdr, correlateFailRequest) 1348 { 1349 static const struct pldm_msg_hdr req = { 1350 .instance_id = 0, 1351 .reserved = 0, 1352 .datagram = 0, 1353 .request = 1, 1354 .type = 0, 1355 .header_ver = 1, 1356 .command = 0x01, 1357 }; 1358 static const struct pldm_msg_hdr resp = { 1359 .instance_id = 0, 1360 .reserved = 0, 1361 .datagram = 0, 1362 .request = 1, 1363 .type = 0, 1364 .header_ver = 1, 1365 .command = 0x01, 1366 }; 1367 1368 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), false); 1369 } 1370 #endif 1371 1372 #ifdef LIBPLDM_API_TESTING 1373 TEST(PldmMsgHdr, correlateFailType) 1374 { 1375 static const struct pldm_msg_hdr req = { 1376 .instance_id = 0, 1377 .reserved = 0, 1378 .datagram = 0, 1379 .request = 1, 1380 .type = 0, 1381 .header_ver = 1, 1382 .command = 0x01, 1383 }; 1384 static const struct pldm_msg_hdr resp = { 1385 .instance_id = 0, 1386 .reserved = 0, 1387 .datagram = 0, 1388 .request = 0, 1389 .type = 1, 1390 .header_ver = 1, 1391 .command = 0x01, 1392 }; 1393 1394 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), false); 1395 } 1396 #endif 1397 1398 #ifdef LIBPLDM_API_TESTING 1399 TEST(PldmMsgHdr, correlateFailCommand) 1400 { 1401 static const struct pldm_msg_hdr req = { 1402 .instance_id = 0, 1403 .reserved = 0, 1404 .datagram = 0, 1405 .request = 1, 1406 .type = 0, 1407 .header_ver = 1, 1408 .command = 0x01, 1409 }; 1410 static const struct pldm_msg_hdr resp = { 1411 .instance_id = 0, 1412 .reserved = 0, 1413 .datagram = 0, 1414 .request = 0, 1415 .type = 0, 1416 .header_ver = 1, 1417 .command = 0x02, 1418 }; 1419 1420 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), false); 1421 } 1422 #endif 1423 1424 #ifdef LIBPLDM_API_TESTING 1425 TEST(PldmMsgHdr, correlateFailRequestIsResponse) 1426 { 1427 static const struct pldm_msg_hdr req = { 1428 .instance_id = 0, 1429 .reserved = 0, 1430 .datagram = 0, 1431 .request = 0, 1432 .type = 0, 1433 .header_ver = 1, 1434 .command = 0x01, 1435 }; 1436 static const struct pldm_msg_hdr resp = { 1437 .instance_id = 0, 1438 .reserved = 0, 1439 .datagram = 0, 1440 .request = 0, 1441 .type = 0, 1442 .header_ver = 1, 1443 .command = 0x02, 1444 }; 1445 1446 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), false); 1447 } 1448 #endif 1449 1450 #ifdef LIBPLDM_API_TESTING 1451 TEST(EncodeNegotiateTransferParamsRequest, GoodTest) 1452 { 1453 uint8_t instance_id = 0; 1454 1455 const struct pldm_base_negotiate_transfer_params_req req_data = { 1456 0x0001, // BE 256 1457 {{0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x81}}}; 1458 1459 std::array<uint8_t, PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES> 1460 requestMsg = {0x01, 0x00, // requester_part_size = 256 1461 0x00, 0x00, 0x00, 0x00, 1462 0x00, 0x00, 0x00, 0x81}; // requester_protocol_support = 1463 // PLDM_BASE & PLDM_FILE 1464 1465 PLDM_MSG_DEFINE_P(requestPtr, 1466 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1467 auto rc = encode_pldm_base_negotiate_transfer_params_req( 1468 instance_id, &req_data, requestPtr, 1469 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1470 1471 ASSERT_EQ(rc, 0); 1472 EXPECT_EQ( 1473 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg))); 1474 } 1475 #endif 1476 1477 #ifdef LIBPLDM_API_TESTING 1478 TEST(EncodeNegotiateTransferParamsRequest, BadTestUnAllocatedPtrParams) 1479 { 1480 int rc; 1481 uint8_t instance_id = 0; 1482 const struct pldm_base_negotiate_transfer_params_req req_data = { 1483 0x0001, // BE 256 1484 {{0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x81}}}; 1485 1486 PLDM_MSG_DEFINE_P(requestPtr, 1487 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1488 rc = encode_pldm_base_negotiate_transfer_params_req( 1489 instance_id, nullptr, requestPtr, 1490 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1491 EXPECT_EQ(rc, -EINVAL); 1492 1493 rc = encode_pldm_base_negotiate_transfer_params_req( 1494 instance_id, &req_data, nullptr, 1495 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1496 EXPECT_EQ(rc, -EINVAL); 1497 } 1498 #endif 1499 1500 #ifdef LIBPLDM_API_TESTING 1501 TEST(EncodeNegotiateTransferParamsRequest, 1502 BadTestInvalidExpectedOutputMsgLength) 1503 { 1504 int rc; 1505 uint8_t instance_id = 0; 1506 const struct pldm_base_negotiate_transfer_params_req req_data = { 1507 0x0001, // BE 256 1508 {{0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x81}}}; 1509 1510 PLDM_MSG_DEFINE_P(requestPtr, 1511 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1512 1513 rc = encode_pldm_base_negotiate_transfer_params_req(instance_id, &req_data, 1514 requestPtr, 1); 1515 EXPECT_EQ(rc, -EOVERFLOW); 1516 } 1517 #endif 1518 1519 #ifdef LIBPLDM_API_TESTING 1520 TEST(DecodeNegotiateTransferParamsResponse, GoodTest) 1521 { 1522 uint8_t completionCode = PLDM_SUCCESS; 1523 uint16_t responderPartSize = 128; 1524 std::array<uint8_t, 8> responderProtocolSupport = {0x00, 0x00, 0x00, 0x00, 1525 0x00, 0x00, 0x00, 0x81}; 1526 1527 struct pldm_base_negotiate_transfer_params_resp resp_data = {}; 1528 1529 PLDM_MSGBUF_DEFINE_P(buf); 1530 int rc; 1531 1532 static constexpr const size_t payload_length = 1533 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_RESP_BYTES; 1534 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 1535 1536 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 1537 ASSERT_EQ(rc, 0); 1538 1539 pldm_msgbuf_insert_uint8(buf, completionCode); 1540 pldm_msgbuf_insert_uint16(buf, responderPartSize); 1541 rc = pldm_msgbuf_insert_array_uint8( 1542 buf, sizeof(resp_data.responder_protocol_support), 1543 responderProtocolSupport.data(), 1544 sizeof(resp_data.responder_protocol_support)); 1545 EXPECT_EQ(rc, 0); 1546 1547 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 1548 1549 rc = decode_pldm_base_negotiate_transfer_params_resp( 1550 responseMsg, payload_length, &resp_data); 1551 1552 ASSERT_EQ(rc, 0); 1553 EXPECT_EQ(resp_data.completion_code, completionCode); 1554 EXPECT_EQ(resp_data.responder_part_size, responderPartSize); 1555 EXPECT_EQ(0, memcmp(responderProtocolSupport.data(), 1556 resp_data.responder_protocol_support, 1557 sizeof(resp_data.responder_protocol_support))); 1558 } 1559 #endif 1560 1561 #ifdef LIBPLDM_API_TESTING 1562 TEST(DecodeNegotiateTransferParamsResponse, BadTestUnAllocatedPtrParams) 1563 { 1564 uint8_t completionCode = PLDM_SUCCESS; 1565 uint16_t responderPartSize = 128; 1566 std::array<uint8_t, 8> responderProtocolSupport = {0x00, 0x00, 0x00, 0x00, 1567 0x00, 0x00, 0x00, 0x81}; 1568 1569 struct pldm_base_negotiate_transfer_params_resp resp_data = {}; 1570 1571 PLDM_MSGBUF_DEFINE_P(buf); 1572 int rc; 1573 1574 static constexpr const size_t payload_length = 1575 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_RESP_BYTES; 1576 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 1577 1578 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 1579 ASSERT_EQ(rc, 0); 1580 1581 pldm_msgbuf_insert_uint8(buf, completionCode); 1582 pldm_msgbuf_insert_uint16(buf, responderPartSize); 1583 rc = pldm_msgbuf_insert_array_uint8( 1584 buf, sizeof(resp_data.responder_protocol_support), 1585 responderProtocolSupport.data(), 1586 sizeof(resp_data.responder_protocol_support)); 1587 EXPECT_EQ(rc, 0); 1588 1589 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 1590 1591 rc = decode_pldm_base_negotiate_transfer_params_resp( 1592 nullptr, payload_length, &resp_data); 1593 1594 EXPECT_EQ(rc, -EINVAL); 1595 1596 rc = decode_pldm_base_negotiate_transfer_params_resp( 1597 responseMsg, payload_length, nullptr); 1598 1599 EXPECT_EQ(rc, -EINVAL); 1600 } 1601 #endif 1602 1603 #ifdef LIBPLDM_API_TESTING 1604 TEST(DecodeNegotiateTransferParamsResponse, 1605 BadTestInvalidExpectedInputMsgLength) 1606 { 1607 uint8_t completionCode = PLDM_SUCCESS; 1608 uint16_t responderPartSize = 128; 1609 std::array<uint8_t, 8> responderProtocolSupport = {0x00, 0x00, 0x00, 0x00, 1610 0x00, 0x00, 0x00, 0x81}; 1611 1612 struct pldm_base_negotiate_transfer_params_resp resp_data = {}; 1613 1614 PLDM_MSGBUF_DEFINE_P(buf); 1615 int rc; 1616 1617 static constexpr const size_t payload_length = 1618 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_RESP_BYTES; 1619 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 1620 1621 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 1622 ASSERT_EQ(rc, 0); 1623 1624 pldm_msgbuf_insert_uint8(buf, completionCode); 1625 pldm_msgbuf_insert_uint16(buf, responderPartSize); 1626 rc = pldm_msgbuf_insert_array_uint8( 1627 buf, sizeof(resp_data.responder_protocol_support), 1628 responderProtocolSupport.data(), 1629 sizeof(resp_data.responder_protocol_support)); 1630 EXPECT_EQ(rc, 0); 1631 1632 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 1633 1634 rc = decode_pldm_base_negotiate_transfer_params_resp(responseMsg, 0, 1635 &resp_data); 1636 1637 EXPECT_EQ(rc, -EOVERFLOW); 1638 } 1639 #endif