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 TEST(CcOnlyResponse, testEncode) 972 { 973 struct pldm_msg responseMsg; 974 975 auto rc = 976 encode_cc_only_resp(0 /*instance id*/, 1 /*pldm type*/, 2 /*command*/, 977 3 /*completion code*/, &responseMsg); 978 EXPECT_EQ(rc, PLDM_SUCCESS); 979 980 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 981 auto p = reinterpret_cast<uint8_t*>(&responseMsg); 982 EXPECT_THAT(std::vector<uint8_t>(p, p + sizeof(responseMsg)), 983 ElementsAreArray({0, 1, 2, 3})); 984 985 rc = encode_cc_only_resp(PLDM_INSTANCE_MAX + 1, 1, 2, 3, &responseMsg); 986 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 987 988 rc = encode_cc_only_resp(0, 1, 2, 3, nullptr); 989 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 990 } 991 992 TEST(SetTID, testGoodEncodeRequest) 993 { 994 uint8_t instanceId = 0; 995 uint8_t tid = 0x01; 996 std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(tid)> requestMsg{}; 997 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 998 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 999 1000 auto rc = encode_set_tid_req(instanceId, tid, request); 1001 ASSERT_EQ(rc, PLDM_SUCCESS); 1002 1003 EXPECT_EQ(request->hdr.command, PLDM_SET_TID); 1004 EXPECT_EQ(request->hdr.type, PLDM_BASE); 1005 EXPECT_EQ(request->hdr.request, 1); 1006 EXPECT_EQ(request->hdr.datagram, 0); 1007 EXPECT_EQ(request->hdr.instance_id, instanceId); 1008 EXPECT_EQ(0, memcmp(request->payload, &tid, sizeof(tid))); 1009 } 1010 1011 TEST(SetTID, testBadEncodeRequest) 1012 { 1013 uint8_t tid = 0x01; 1014 std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(tid)> requestMsg{}; 1015 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1016 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 1017 1018 auto rc = encode_set_tid_req(0, tid, nullptr); 1019 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 1020 1021 rc = encode_set_tid_req(0, 0, request); 1022 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 1023 1024 rc = encode_set_tid_req(0, 0xff, request); 1025 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 1026 } 1027 1028 #ifdef LIBPLDM_API_TESTING 1029 TEST(SetTID, testGoodDecodeRequest) 1030 { 1031 uint8_t tid = 0x01; 1032 uint8_t tidOut = 0x00; 1033 std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(tid)> requestMsg{}; 1034 1035 requestMsg[sizeof(pldm_msg_hdr)] = tid; 1036 1037 pldm_msg* request = new (requestMsg.data()) pldm_msg; 1038 auto rc = decode_set_tid_req( 1039 request, requestMsg.size() - sizeof(pldm_msg_hdr), &tidOut); 1040 1041 EXPECT_EQ(rc, PLDM_SUCCESS); 1042 EXPECT_EQ(tid, tidOut); 1043 } 1044 #endif 1045 1046 #ifdef LIBPLDM_API_TESTING 1047 TEST(SetTID, testBadDecodeRequestMsg) 1048 { 1049 uint8_t tid = 0x01; 1050 std::array<uint8_t, hdrSize + PLDM_SET_TID_REQ_BYTES> requestMsg{}; 1051 1052 auto rc = decode_set_tid_req( 1053 nullptr, requestMsg.size() - sizeof(pldm_msg_hdr), &tid); 1054 1055 EXPECT_EQ(rc, -EINVAL); 1056 } 1057 #endif 1058 1059 #ifdef LIBPLDM_API_TESTING 1060 TEST(SetTID, testBadDecodeRequestTid) 1061 { 1062 std::array<uint8_t, hdrSize + PLDM_SET_TID_REQ_BYTES> requestMsg{}; 1063 pldm_msg* request = new (requestMsg.data()) pldm_msg; 1064 1065 auto rc = decode_set_tid_req( 1066 request, requestMsg.size() - sizeof(pldm_msg_hdr), nullptr); 1067 1068 EXPECT_EQ(rc, -EINVAL); 1069 } 1070 #endif 1071 1072 #ifdef LIBPLDM_API_TESTING 1073 TEST(SetTID, testBadDecodeRequestMsgSize) 1074 { 1075 std::array<uint8_t, hdrSize + PLDM_SET_TID_REQ_BYTES> requestMsg{}; 1076 pldm_msg* request = new (requestMsg.data()) pldm_msg; 1077 1078 auto rc = decode_set_tid_req(request, -1, nullptr); 1079 1080 EXPECT_EQ(rc, -EINVAL); 1081 } 1082 #endif 1083 1084 #ifdef LIBPLDM_API_TESTING 1085 TEST(PldmMsgHdr, correlateSuccess) 1086 { 1087 static const struct pldm_msg_hdr req = { 1088 .instance_id = 0, 1089 .reserved = 0, 1090 .datagram = 0, 1091 .request = 1, 1092 .type = 0, 1093 .header_ver = 1, 1094 .command = 0x01, 1095 }; 1096 static const struct pldm_msg_hdr resp = { 1097 .instance_id = 0, 1098 .reserved = 0, 1099 .datagram = 0, 1100 .request = 0, 1101 .type = 0, 1102 .header_ver = 1, 1103 .command = 0x01, 1104 }; 1105 1106 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), true); 1107 } 1108 #endif 1109 1110 #ifdef LIBPLDM_API_TESTING 1111 TEST(PldmMsgHdr, correlateFailInstanceID) 1112 { 1113 static const struct pldm_msg_hdr req = { 1114 .instance_id = 0, 1115 .reserved = 0, 1116 .datagram = 0, 1117 .request = 1, 1118 .type = 0, 1119 .header_ver = 1, 1120 .command = 0x01, 1121 }; 1122 static const struct pldm_msg_hdr resp = { 1123 .instance_id = 1, 1124 .reserved = 0, 1125 .datagram = 0, 1126 .request = 0, 1127 .type = 0, 1128 .header_ver = 1, 1129 .command = 0x01, 1130 }; 1131 1132 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), false); 1133 } 1134 #endif 1135 1136 #ifdef LIBPLDM_API_TESTING 1137 TEST(PldmMsgHdr, correlateFailRequest) 1138 { 1139 static const struct pldm_msg_hdr req = { 1140 .instance_id = 0, 1141 .reserved = 0, 1142 .datagram = 0, 1143 .request = 1, 1144 .type = 0, 1145 .header_ver = 1, 1146 .command = 0x01, 1147 }; 1148 static const struct pldm_msg_hdr resp = { 1149 .instance_id = 0, 1150 .reserved = 0, 1151 .datagram = 0, 1152 .request = 1, 1153 .type = 0, 1154 .header_ver = 1, 1155 .command = 0x01, 1156 }; 1157 1158 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), false); 1159 } 1160 #endif 1161 1162 #ifdef LIBPLDM_API_TESTING 1163 TEST(PldmMsgHdr, correlateFailType) 1164 { 1165 static const struct pldm_msg_hdr req = { 1166 .instance_id = 0, 1167 .reserved = 0, 1168 .datagram = 0, 1169 .request = 1, 1170 .type = 0, 1171 .header_ver = 1, 1172 .command = 0x01, 1173 }; 1174 static const struct pldm_msg_hdr resp = { 1175 .instance_id = 0, 1176 .reserved = 0, 1177 .datagram = 0, 1178 .request = 0, 1179 .type = 1, 1180 .header_ver = 1, 1181 .command = 0x01, 1182 }; 1183 1184 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), false); 1185 } 1186 #endif 1187 1188 #ifdef LIBPLDM_API_TESTING 1189 TEST(PldmMsgHdr, correlateFailCommand) 1190 { 1191 static const struct pldm_msg_hdr req = { 1192 .instance_id = 0, 1193 .reserved = 0, 1194 .datagram = 0, 1195 .request = 1, 1196 .type = 0, 1197 .header_ver = 1, 1198 .command = 0x01, 1199 }; 1200 static const struct pldm_msg_hdr resp = { 1201 .instance_id = 0, 1202 .reserved = 0, 1203 .datagram = 0, 1204 .request = 0, 1205 .type = 0, 1206 .header_ver = 1, 1207 .command = 0x02, 1208 }; 1209 1210 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), false); 1211 } 1212 #endif 1213 1214 #ifdef LIBPLDM_API_TESTING 1215 TEST(PldmMsgHdr, correlateFailRequestIsResponse) 1216 { 1217 static const struct pldm_msg_hdr req = { 1218 .instance_id = 0, 1219 .reserved = 0, 1220 .datagram = 0, 1221 .request = 0, 1222 .type = 0, 1223 .header_ver = 1, 1224 .command = 0x01, 1225 }; 1226 static const struct pldm_msg_hdr resp = { 1227 .instance_id = 0, 1228 .reserved = 0, 1229 .datagram = 0, 1230 .request = 0, 1231 .type = 0, 1232 .header_ver = 1, 1233 .command = 0x02, 1234 }; 1235 1236 ASSERT_EQ(pldm_msg_hdr_correlate_response(&req, &resp), false); 1237 } 1238 #endif 1239 1240 #ifdef LIBPLDM_API_TESTING 1241 TEST(EncodeNegotiateTransferParamsRequest, GoodTest) 1242 { 1243 uint8_t instance_id = 0; 1244 1245 const struct pldm_base_negotiate_transfer_params_req req_data = { 1246 0x0001, // BE 256 1247 {{0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x81}}}; 1248 1249 std::array<uint8_t, PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES> 1250 requestMsg = {0x01, 0x00, // requester_part_size = 256 1251 0x00, 0x00, 0x00, 0x00, 1252 0x00, 0x00, 0x00, 0x81}; // requester_protocol_support = 1253 // PLDM_BASE & PLDM_FILE 1254 1255 PLDM_MSG_DEFINE_P(requestPtr, 1256 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1257 auto rc = encode_pldm_base_negotiate_transfer_params_req( 1258 instance_id, &req_data, requestPtr, 1259 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1260 1261 ASSERT_EQ(rc, 0); 1262 EXPECT_EQ( 1263 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg))); 1264 } 1265 #endif 1266 1267 #ifdef LIBPLDM_API_TESTING 1268 TEST(EncodeNegotiateTransferParamsRequest, BadTestUnAllocatedPtrParams) 1269 { 1270 int rc; 1271 uint8_t instance_id = 0; 1272 const struct pldm_base_negotiate_transfer_params_req req_data = { 1273 0x0001, // BE 256 1274 {{0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x81}}}; 1275 1276 PLDM_MSG_DEFINE_P(requestPtr, 1277 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1278 rc = encode_pldm_base_negotiate_transfer_params_req( 1279 instance_id, nullptr, requestPtr, 1280 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1281 EXPECT_EQ(rc, -EINVAL); 1282 1283 rc = encode_pldm_base_negotiate_transfer_params_req( 1284 instance_id, &req_data, nullptr, 1285 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1286 EXPECT_EQ(rc, -EINVAL); 1287 } 1288 #endif 1289 1290 #ifdef LIBPLDM_API_TESTING 1291 TEST(EncodeNegotiateTransferParamsRequest, 1292 BadTestInvalidExpectedOutputMsgLength) 1293 { 1294 int rc; 1295 uint8_t instance_id = 0; 1296 const struct pldm_base_negotiate_transfer_params_req req_data = { 1297 0x0001, // BE 256 1298 {{0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x00}, {0x81}}}; 1299 1300 PLDM_MSG_DEFINE_P(requestPtr, 1301 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES); 1302 1303 rc = encode_pldm_base_negotiate_transfer_params_req(instance_id, &req_data, 1304 requestPtr, 1); 1305 EXPECT_EQ(rc, -EOVERFLOW); 1306 } 1307 #endif 1308 1309 #ifdef LIBPLDM_API_TESTING 1310 TEST(DecodeNegotiateTransferParamsResponse, GoodTest) 1311 { 1312 uint8_t completionCode = PLDM_SUCCESS; 1313 uint16_t responderPartSize = 128; 1314 std::array<uint8_t, 8> responderProtocolSupport = {0x00, 0x00, 0x00, 0x00, 1315 0x00, 0x00, 0x00, 0x81}; 1316 1317 struct pldm_base_negotiate_transfer_params_resp resp_data = {}; 1318 1319 PLDM_MSGBUF_DEFINE_P(buf); 1320 int rc; 1321 1322 static constexpr const size_t payload_length = 1323 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_RESP_BYTES; 1324 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 1325 1326 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 1327 ASSERT_EQ(rc, 0); 1328 1329 pldm_msgbuf_insert_uint8(buf, completionCode); 1330 pldm_msgbuf_insert_uint16(buf, responderPartSize); 1331 rc = pldm_msgbuf_insert_array_uint8( 1332 buf, sizeof(resp_data.responder_protocol_support), 1333 responderProtocolSupport.data(), 1334 sizeof(resp_data.responder_protocol_support)); 1335 EXPECT_EQ(rc, 0); 1336 1337 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 1338 1339 rc = decode_pldm_base_negotiate_transfer_params_resp( 1340 responseMsg, payload_length, &resp_data); 1341 1342 ASSERT_EQ(rc, 0); 1343 EXPECT_EQ(resp_data.completion_code, completionCode); 1344 EXPECT_EQ(resp_data.responder_part_size, responderPartSize); 1345 EXPECT_EQ(0, memcmp(responderProtocolSupport.data(), 1346 resp_data.responder_protocol_support, 1347 sizeof(resp_data.responder_protocol_support))); 1348 } 1349 #endif 1350 1351 #ifdef LIBPLDM_API_TESTING 1352 TEST(DecodeNegotiateTransferParamsResponse, BadTestUnAllocatedPtrParams) 1353 { 1354 uint8_t completionCode = PLDM_SUCCESS; 1355 uint16_t responderPartSize = 128; 1356 std::array<uint8_t, 8> responderProtocolSupport = {0x00, 0x00, 0x00, 0x00, 1357 0x00, 0x00, 0x00, 0x81}; 1358 1359 struct pldm_base_negotiate_transfer_params_resp resp_data = {}; 1360 1361 PLDM_MSGBUF_DEFINE_P(buf); 1362 int rc; 1363 1364 static constexpr const size_t payload_length = 1365 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_RESP_BYTES; 1366 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 1367 1368 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 1369 ASSERT_EQ(rc, 0); 1370 1371 pldm_msgbuf_insert_uint8(buf, completionCode); 1372 pldm_msgbuf_insert_uint16(buf, responderPartSize); 1373 rc = pldm_msgbuf_insert_array_uint8( 1374 buf, sizeof(resp_data.responder_protocol_support), 1375 responderProtocolSupport.data(), 1376 sizeof(resp_data.responder_protocol_support)); 1377 EXPECT_EQ(rc, 0); 1378 1379 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 1380 1381 rc = decode_pldm_base_negotiate_transfer_params_resp( 1382 nullptr, payload_length, &resp_data); 1383 1384 EXPECT_EQ(rc, -EINVAL); 1385 1386 rc = decode_pldm_base_negotiate_transfer_params_resp( 1387 responseMsg, payload_length, nullptr); 1388 1389 EXPECT_EQ(rc, -EINVAL); 1390 } 1391 #endif 1392 1393 #ifdef LIBPLDM_API_TESTING 1394 TEST(DecodeNegotiateTransferParamsResponse, 1395 BadTestInvalidExpectedInputMsgLength) 1396 { 1397 uint8_t completionCode = PLDM_SUCCESS; 1398 uint16_t responderPartSize = 128; 1399 std::array<uint8_t, 8> responderProtocolSupport = {0x00, 0x00, 0x00, 0x00, 1400 0x00, 0x00, 0x00, 0x81}; 1401 1402 struct pldm_base_negotiate_transfer_params_resp resp_data = {}; 1403 1404 PLDM_MSGBUF_DEFINE_P(buf); 1405 int rc; 1406 1407 static constexpr const size_t payload_length = 1408 PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_RESP_BYTES; 1409 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 1410 1411 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 1412 ASSERT_EQ(rc, 0); 1413 1414 pldm_msgbuf_insert_uint8(buf, completionCode); 1415 pldm_msgbuf_insert_uint16(buf, responderPartSize); 1416 rc = pldm_msgbuf_insert_array_uint8( 1417 buf, sizeof(resp_data.responder_protocol_support), 1418 responderProtocolSupport.data(), 1419 sizeof(resp_data.responder_protocol_support)); 1420 EXPECT_EQ(rc, 0); 1421 1422 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 1423 1424 rc = decode_pldm_base_negotiate_transfer_params_resp(responseMsg, 0, 1425 &resp_data); 1426 1427 EXPECT_EQ(rc, -EOVERFLOW); 1428 } 1429 #endif