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