1 /* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */ 2 #include <endian.h> 3 #include <libpldm/oem/meta/file_io.h> 4 5 #include <cstdlib> 6 #include <new> 7 8 #include "msgbuf.h" 9 10 #include "gmock/gmock.h" 11 #include <gtest/gtest.h> 12 13 TEST(DecodeOemMetaFileIoWriteReq, testGoodDecodeRequest) 14 { 15 constexpr const uint8_t postCode[4] = {0x93, 0xe0, 0x00, 0xea}; 16 PLDM_MSGBUF_DEFINE_P(ctx); 17 int rc; 18 19 constexpr size_t encodedPayloadLen = 20 PLDM_OEM_META_FILE_IO_WRITE_REQ_MIN_LENGTH + sizeof(postCode); 21 constexpr size_t encodedMsgLen = sizeof(pldm_msg_hdr) + encodedPayloadLen; 22 alignas(pldm_msg) unsigned char encodedMsgBuf[encodedMsgLen] = {}; 23 auto* encodedMsg = new (encodedMsgBuf) pldm_msg; 24 25 rc = pldm_msgbuf_init_errno(ctx, 0, encodedMsg->payload, encodedPayloadLen); 26 ASSERT_EQ(rc, 0); 27 28 pldm_msgbuf_insert_uint8(ctx, 0); 29 pldm_msgbuf_insert_int32(ctx, sizeof(postCode)); 30 rc = pldm_msgbuf_insert_array_uint8(ctx, sizeof(postCode), postCode, 31 sizeof(postCode)); 32 ASSERT_EQ(rc, 0); 33 34 rc = pldm_msgbuf_complete_consumed(ctx); 35 ASSERT_EQ(rc, 0); 36 37 constexpr size_t decodedReqLen = 38 sizeof(struct pldm_oem_meta_file_io_write_req) + sizeof(postCode); 39 alignas(pldm_oem_meta_file_io_write_req) unsigned char 40 decodedReqBuf[decodedReqLen]; 41 auto* decodedReq = new (decodedReqBuf) pldm_oem_meta_file_io_write_req; 42 auto* decodedReqData = 43 static_cast<uint8_t*>(pldm_oem_meta_file_io_write_req_data(decodedReq)); 44 45 rc = decode_oem_meta_file_io_write_req(encodedMsg, encodedPayloadLen, 46 decodedReq, decodedReqLen); 47 ASSERT_EQ(rc, 0); 48 49 EXPECT_EQ(decodedReq->handle, 0); 50 ASSERT_EQ(decodedReq->length, sizeof(postCode)); 51 EXPECT_EQ(memcmp(decodedReqData, postCode, decodedReq->length), 0); 52 } 53 54 TEST(DecodeOemMetaFileIoWriteReq, testInvalidFieldsDecodeRequest) 55 { 56 struct pldm_msg msg = {}; 57 58 auto rc = decode_oem_meta_file_io_write_req(&msg, sizeof(msg), NULL, 0); 59 EXPECT_EQ(rc, -EINVAL); 60 } 61 62 TEST(DecodeOemMetaFileIoWriteReq, testInvalidLengthDecodeRequest) 63 { 64 struct pldm_oem_meta_file_io_write_req req = {}; 65 struct pldm_msg msg = {}; 66 67 auto rc = decode_oem_meta_file_io_write_req(&msg, 0, &req, sizeof(req)); 68 EXPECT_EQ(rc, -EOVERFLOW); 69 } 70 71 TEST(DecodeOemMetaFileIoWriteReq, testInvalidDataRequest) 72 { 73 struct pldm_oem_meta_file_io_write_req req = {}; 74 struct pldm_msg msg = {}; 75 int rc; 76 77 rc = decode_oem_meta_file_io_write_req( 78 &msg, PLDM_OEM_META_FILE_IO_WRITE_REQ_MIN_LENGTH - 1, &req, 79 sizeof(req)); 80 EXPECT_EQ(rc, -EOVERFLOW); 81 } 82 83 TEST(DecodeOemMetaFileIoReadReq, testGoodDecodeRequest) 84 { 85 PLDM_MSGBUF_DEFINE_P(ctx); 86 int rc; 87 88 constexpr size_t payloadLen = PLDM_OEM_META_FILE_IO_READ_REQ_MIN_LENGTH + 89 PLDM_OEM_META_FILE_IO_READ_DATA_INFO_LENGTH; 90 alignas(pldm_msg) unsigned char buf[sizeof(pldm_msg_hdr) + payloadLen]{}; 91 auto* msg = new (buf) pldm_msg; 92 93 rc = pldm_msgbuf_init_errno(ctx, 0, msg->payload, payloadLen); 94 ASSERT_EQ(rc, 0); 95 96 pldm_msgbuf_insert_uint8(ctx, 0); 97 pldm_msgbuf_insert_uint8(ctx, PLDM_OEM_META_FILE_IO_READ_DATA); 98 pldm_msgbuf_insert_uint8(ctx, PLDM_OEM_META_FILE_IO_READ_DATA_INFO_LENGTH); 99 pldm_msgbuf_insert_uint8(ctx, 1); 100 pldm_msgbuf_insert_uint16(ctx, 1223); 101 102 rc = pldm_msgbuf_complete_consumed(ctx); 103 ASSERT_EQ(rc, 0); 104 105 struct pldm_oem_meta_file_io_read_req req = {}; 106 req.version = sizeof(req); 107 rc = decode_oem_meta_file_io_read_req(msg, payloadLen, &req); 108 ASSERT_EQ(rc, 0); 109 110 EXPECT_EQ(req.handle, 0); 111 EXPECT_EQ(req.option, PLDM_OEM_META_FILE_IO_READ_DATA); 112 EXPECT_EQ(req.length, PLDM_OEM_META_FILE_IO_READ_DATA_INFO_LENGTH); 113 EXPECT_EQ(req.info.data.transferFlag, 1); 114 EXPECT_EQ(req.info.data.offset, 1223); 115 } 116 117 TEST(DecodeOemMetaFileIoReadReq, testInvalidFieldsDecodeRequest) 118 { 119 struct pldm_msg msg = {}; 120 121 auto rc = decode_oem_meta_file_io_read_req( 122 &msg, PLDM_OEM_META_FILE_IO_READ_REQ_MIN_LENGTH, NULL); 123 EXPECT_EQ(rc, -EINVAL); 124 } 125 126 TEST(DecodeOemMetaFileIoReadReq, testInvalidLengthDecodeRequest) 127 { 128 struct pldm_oem_meta_file_io_read_req req = {}; 129 struct pldm_msg msg = {}; 130 131 auto rc = decode_oem_meta_file_io_read_req(&msg, 0, &req); 132 EXPECT_EQ(rc, -EOVERFLOW); 133 } 134 135 TEST(DecodeOemMetaFileIoReadReq, testInvalidDataRequest) 136 { 137 struct pldm_oem_meta_file_io_read_req req = {}; 138 struct pldm_msg msg = {}; 139 140 auto rc = decode_oem_meta_file_io_read_req( 141 &msg, PLDM_OEM_META_FILE_IO_READ_REQ_MIN_LENGTH - 1, &req); 142 EXPECT_EQ(rc, -EOVERFLOW); 143 } 144 145 TEST(EncodeOemMetaFileIoReadResp, testGoodEncodeReadAttrResponse) 146 { 147 int rc; 148 149 alignas(pldm_oem_meta_file_io_read_resp) unsigned char 150 decodedBuf[sizeof(pldm_oem_meta_file_io_read_resp)]; 151 auto* resp = new (decodedBuf) pldm_oem_meta_file_io_read_resp; 152 resp->version = sizeof(struct pldm_oem_meta_file_io_read_resp); 153 resp->completion_code = PLDM_SUCCESS; 154 resp->handle = 1; 155 resp->option = PLDM_OEM_META_FILE_IO_READ_ATTR; 156 resp->length = 0; 157 resp->info.attr.size = 0x1284; 158 resp->info.attr.crc32 = 0xab715432; 159 160 constexpr size_t payloadLen = PLDM_OEM_META_FILE_IO_READ_RESP_MIN_SIZE + 161 PLDM_OEM_META_FILE_IO_READ_ATTR_INFO_LENGTH; 162 alignas(pldm_msg) unsigned char 163 encodedBuf[sizeof(pldm_msg_hdr) + payloadLen] = {}; 164 auto* msg = new (encodedBuf) pldm_msg; 165 166 rc = encode_oem_meta_file_io_read_resp( 167 0, resp, sizeof(pldm_oem_meta_file_io_read_resp), msg, payloadLen); 168 ASSERT_EQ(rc, 0); 169 170 EXPECT_THAT(encodedBuf, testing::ElementsAreArray( 171 {0x00, 0x3f, 0x03, 0x00, 0x01, 0x00, 0x00, 0x84, 172 0x12, 0x32, 0x54, 0x71, 0xab})); 173 } 174 175 TEST(EncodeOemMetaFileIoReadResp, testGoodEncodeReadDataResponse) 176 { 177 constexpr static const uint8_t readbuf[4] = {0x23, 0xca, 0x84, 0x9d}; 178 int rc; 179 180 alignas(pldm_oem_meta_file_io_read_resp) unsigned char 181 decodedBuf[sizeof(pldm_oem_meta_file_io_read_resp) + sizeof(readbuf)]; 182 auto* resp = new (decodedBuf) pldm_oem_meta_file_io_read_resp; 183 resp->version = sizeof(struct pldm_oem_meta_file_io_read_resp); 184 resp->completion_code = PLDM_SUCCESS; 185 resp->handle = 1; 186 resp->option = PLDM_OEM_META_FILE_IO_READ_DATA; 187 resp->length = 4; 188 resp->info.data.transferFlag = 0x05; 189 resp->info.data.offset = 0x75cd; 190 memcpy(pldm_oem_meta_file_io_read_resp_data(resp), readbuf, 191 sizeof(readbuf)); 192 193 constexpr size_t payloadLen = PLDM_OEM_META_FILE_IO_READ_RESP_MIN_SIZE + 194 PLDM_OEM_META_FILE_IO_READ_DATA_INFO_LENGTH + 195 sizeof(readbuf); 196 alignas(pldm_msg) unsigned char 197 encodedBuf[sizeof(pldm_msg_hdr) + payloadLen] = {}; 198 auto* msg = new (encodedBuf) pldm_msg; 199 200 rc = encode_oem_meta_file_io_read_resp( 201 0, resp, sizeof(pldm_oem_meta_file_io_read_resp) + sizeof(readbuf), msg, 202 payloadLen); 203 ASSERT_EQ(rc, 0); 204 205 EXPECT_THAT(encodedBuf, testing::ElementsAreArray( 206 {0x00, 0x3f, 0x03, 0x00, 0x01, 0x01, 0x04, 0x05, 207 0xcd, 0x75, 0x23, 0xca, 0x84, 0x9d})); 208 } 209 210 TEST(EncodeOemMetaFileIoReadResp, testInvalidFieldsEncodeResponse) 211 { 212 struct pldm_msg msg = {}; 213 214 auto rc = encode_oem_meta_file_io_read_resp( 215 0, NULL, 0, &msg, PLDM_OEM_META_FILE_IO_READ_RESP_MIN_SIZE); 216 EXPECT_EQ(rc, -EINVAL); 217 } 218 219 TEST(EncodeOemMetaFileIoReadResp, testInvalidLengthEncodeResponse) 220 { 221 struct pldm_oem_meta_file_io_read_resp resp = {}; 222 struct pldm_msg msg = {}; 223 224 auto rc = 225 encode_oem_meta_file_io_read_resp(0, &resp, sizeof(resp), &msg, 0); 226 EXPECT_EQ(rc, -EOVERFLOW); 227 } 228 229 TEST(EncodeOemMetaFileIoReadResp, testInvalidDataEncodeResponse) 230 { 231 struct pldm_oem_meta_file_io_read_resp resp = {}; 232 struct pldm_msg msg = {}; 233 234 auto rc = encode_oem_meta_file_io_read_resp( 235 0, &resp, sizeof(resp), &msg, 236 PLDM_OEM_META_FILE_IO_READ_RESP_MIN_SIZE - 1); 237 EXPECT_EQ(rc, -EOVERFLOW); 238 } 239