1 /*
2 * Copyright 2015-2023 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 #include "internal/packet_quic.h"
11 #include "testutil.h"
12
13 #define BUF_LEN 255
14
15 static unsigned char smbuf[BUF_LEN + 1];
16
test_PACKET_remaining(void)17 static int test_PACKET_remaining(void)
18 {
19 PACKET pkt;
20
21 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
22 || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
23 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
24 || !TEST_size_t_eq(PACKET_remaining(&pkt), 1)
25 || !TEST_true(PACKET_forward(&pkt, 1))
26 || !TEST_size_t_eq(PACKET_remaining(&pkt), 0))
27 return 0;
28
29 return 1;
30 }
31
test_PACKET_end(void)32 static int test_PACKET_end(void)
33 {
34 PACKET pkt;
35
36 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
37 || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
38 || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
39 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
40 || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
41 || !TEST_true(PACKET_forward(&pkt, 1))
42 || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN))
43 return 0;
44
45 return 1;
46 }
47
test_PACKET_get_1(void)48 static int test_PACKET_get_1(void)
49 {
50 unsigned int i = 0;
51 PACKET pkt;
52
53 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
54 || !TEST_true(PACKET_get_1(&pkt, &i))
55 || !TEST_uint_eq(i, 0x02)
56 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 2))
57 || !TEST_true(PACKET_get_1(&pkt, &i))
58 || !TEST_uint_eq(i, 0xfe)
59 || !TEST_false(PACKET_get_1(&pkt, &i)))
60 return 0;
61
62 return 1;
63 }
64
test_PACKET_get_4(void)65 static int test_PACKET_get_4(void)
66 {
67 unsigned long i = 0;
68 PACKET pkt;
69
70 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
71 || !TEST_true(PACKET_get_4(&pkt, &i))
72 || !TEST_ulong_eq(i, 0x08060402UL)
73 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
74 || !TEST_true(PACKET_get_4(&pkt, &i))
75 || !TEST_ulong_eq(i, 0xfefcfaf8UL)
76 || !TEST_false(PACKET_get_4(&pkt, &i)))
77 return 0;
78
79 return 1;
80 }
81
test_PACKET_get_net_2(void)82 static int test_PACKET_get_net_2(void)
83 {
84 unsigned int i = 0;
85 PACKET pkt;
86
87 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
88 || !TEST_true(PACKET_get_net_2(&pkt, &i))
89 || !TEST_uint_eq(i, 0x0204)
90 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 4))
91 || !TEST_true(PACKET_get_net_2(&pkt, &i))
92 || !TEST_uint_eq(i, 0xfcfe)
93 || !TEST_false(PACKET_get_net_2(&pkt, &i)))
94 return 0;
95
96 return 1;
97 }
98
test_PACKET_get_net_3(void)99 static int test_PACKET_get_net_3(void)
100 {
101 unsigned long i = 0;
102 PACKET pkt;
103
104 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
105 || !TEST_true(PACKET_get_net_3(&pkt, &i))
106 || !TEST_ulong_eq(i, 0x020406UL)
107 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 6))
108 || !TEST_true(PACKET_get_net_3(&pkt, &i))
109 || !TEST_ulong_eq(i, 0xfafcfeUL)
110 || !TEST_false(PACKET_get_net_3(&pkt, &i)))
111 return 0;
112
113 return 1;
114 }
115
test_PACKET_get_net_4(void)116 static int test_PACKET_get_net_4(void)
117 {
118 unsigned long i = 0;
119 PACKET pkt;
120
121 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
122 || !TEST_true(PACKET_get_net_4(&pkt, &i))
123 || !TEST_ulong_eq(i, 0x02040608UL)
124 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
125 || !TEST_true(PACKET_get_net_4(&pkt, &i))
126 || !TEST_ulong_eq(i, 0xf8fafcfeUL)
127 || !TEST_false(PACKET_get_net_4(&pkt, &i)))
128 return 0;
129
130 return 1;
131 }
132
test_PACKET_get_sub_packet(void)133 static int test_PACKET_get_sub_packet(void)
134 {
135 PACKET pkt, subpkt;
136 unsigned long i = 0;
137
138 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
139 || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
140 || !TEST_true(PACKET_get_net_4(&subpkt, &i))
141 || !TEST_ulong_eq(i, 0x02040608UL)
142 || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
143 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
144 || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
145 || !TEST_true(PACKET_get_net_4(&subpkt, &i))
146 || !TEST_ulong_eq(i, 0xf8fafcfeUL)
147 || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
148 || !TEST_false(PACKET_get_sub_packet(&pkt, &subpkt, 4)))
149 return 0;
150
151 return 1;
152 }
153
test_PACKET_get_bytes(void)154 static int test_PACKET_get_bytes(void)
155 {
156 const unsigned char *bytes = NULL;
157 PACKET pkt;
158
159 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
160 || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
161 || !TEST_uchar_eq(bytes[0], 2)
162 || !TEST_uchar_eq(bytes[1], 4)
163 || !TEST_uchar_eq(bytes[2], 6)
164 || !TEST_uchar_eq(bytes[3], 8)
165 || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN -4)
166 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
167 || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
168 || !TEST_uchar_eq(bytes[0], 0xf8)
169 || !TEST_uchar_eq(bytes[1], 0xfa)
170 || !TEST_uchar_eq(bytes[2], 0xfc)
171 || !TEST_uchar_eq(bytes[3], 0xfe)
172 || !TEST_false(PACKET_remaining(&pkt)))
173 return 0;
174
175 return 1;
176 }
177
test_PACKET_copy_bytes(void)178 static int test_PACKET_copy_bytes(void)
179 {
180 unsigned char bytes[4];
181 PACKET pkt;
182
183 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
184 || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
185 || !TEST_char_eq(bytes[0], 2)
186 || !TEST_char_eq(bytes[1], 4)
187 || !TEST_char_eq(bytes[2], 6)
188 || !TEST_char_eq(bytes[3], 8)
189 || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN - 4)
190 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
191 || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
192 || !TEST_uchar_eq(bytes[0], 0xf8)
193 || !TEST_uchar_eq(bytes[1], 0xfa)
194 || !TEST_uchar_eq(bytes[2], 0xfc)
195 || !TEST_uchar_eq(bytes[3], 0xfe)
196 || !TEST_false(PACKET_remaining(&pkt)))
197 return 0;
198
199 return 1;
200 }
201
test_PACKET_copy_all(void)202 static int test_PACKET_copy_all(void)
203 {
204 unsigned char tmp[BUF_LEN];
205 PACKET pkt;
206 size_t len;
207
208 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
209 || !TEST_true(PACKET_copy_all(&pkt, tmp, BUF_LEN, &len))
210 || !TEST_size_t_eq(len, BUF_LEN)
211 || !TEST_mem_eq(smbuf, BUF_LEN, tmp, BUF_LEN)
212 || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
213 || !TEST_false(PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)))
214 return 0;
215
216 return 1;
217 }
218
test_PACKET_memdup(void)219 static int test_PACKET_memdup(void)
220 {
221 unsigned char *data = NULL;
222 size_t len;
223 PACKET pkt;
224 int result = 0;
225
226 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
227 || !TEST_true(PACKET_memdup(&pkt, &data, &len))
228 || !TEST_size_t_eq(len, BUF_LEN)
229 || !TEST_mem_eq(data, len, PACKET_data(&pkt), len)
230 || !TEST_true(PACKET_forward(&pkt, 10))
231 || !TEST_true(PACKET_memdup(&pkt, &data, &len))
232 || !TEST_size_t_eq(len, BUF_LEN - 10)
233 || !TEST_mem_eq(data, len, PACKET_data(&pkt), len))
234 goto end;
235 result = 1;
236 end:
237 OPENSSL_free(data);
238 return result;
239 }
240
test_PACKET_strndup(void)241 static int test_PACKET_strndup(void)
242 {
243 char buf1[10], buf2[10];
244 char *data = NULL;
245 PACKET pkt;
246 int result = 0;
247
248 memset(buf1, 'x', 10);
249 memset(buf2, 'y', 10);
250 buf2[5] = '\0';
251
252 if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
253 || !TEST_true(PACKET_strndup(&pkt, &data))
254 || !TEST_size_t_eq(strlen(data), 10)
255 || !TEST_strn_eq(data, buf1, 10)
256 || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
257 || !TEST_true(PACKET_strndup(&pkt, &data))
258 || !TEST_size_t_eq(strlen(data), 5)
259 || !TEST_str_eq(data, buf2))
260 goto end;
261
262 result = 1;
263 end:
264 OPENSSL_free(data);
265 return result;
266 }
267
test_PACKET_contains_zero_byte(void)268 static int test_PACKET_contains_zero_byte(void)
269 {
270 char buf1[10], buf2[10];
271 PACKET pkt;
272
273 memset(buf1, 'x', 10);
274 memset(buf2, 'y', 10);
275 buf2[5] = '\0';
276
277 if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
278 || !TEST_false(PACKET_contains_zero_byte(&pkt))
279 || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
280 || !TEST_true(PACKET_contains_zero_byte(&pkt)))
281 return 0;
282
283 return 1;
284 }
285
test_PACKET_forward(void)286 static int test_PACKET_forward(void)
287 {
288 const unsigned char *byte = NULL;
289 PACKET pkt;
290
291 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
292 || !TEST_true(PACKET_forward(&pkt, 1))
293 || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
294 || !TEST_uchar_eq(byte[0], 4)
295 || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 3))
296 || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
297 || !TEST_uchar_eq(byte[0], 0xfe))
298 return 0;
299
300 return 1;
301 }
302
test_PACKET_buf_init(void)303 static int test_PACKET_buf_init(void)
304 {
305 unsigned char buf1[BUF_LEN] = { 0 };
306 PACKET pkt;
307
308 /* Also tests PACKET_remaining() */
309 if (!TEST_true(PACKET_buf_init(&pkt, buf1, 4))
310 || !TEST_size_t_eq(PACKET_remaining(&pkt), 4)
311 || !TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
312 || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
313 || !TEST_false(PACKET_buf_init(&pkt, buf1, -1)))
314 return 0;
315
316 return 1;
317 }
318
test_PACKET_null_init(void)319 static int test_PACKET_null_init(void)
320 {
321 PACKET pkt;
322
323 PACKET_null_init(&pkt);
324 if (!TEST_size_t_eq(PACKET_remaining(&pkt), 0)
325 || !TEST_false(PACKET_forward(&pkt, 1)))
326 return 0;
327
328 return 1;
329 }
330
test_PACKET_equal(void)331 static int test_PACKET_equal(void)
332 {
333 PACKET pkt;
334
335 if (!TEST_true(PACKET_buf_init(&pkt, smbuf, 4))
336 || !TEST_true(PACKET_equal(&pkt, smbuf, 4))
337 || !TEST_false(PACKET_equal(&pkt, smbuf + 1, 4))
338 || !TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
339 || !TEST_true(PACKET_equal(&pkt, smbuf, BUF_LEN))
340 || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN - 1))
341 || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN + 1))
342 || !TEST_false(PACKET_equal(&pkt, smbuf, 0)))
343 return 0;
344
345 return 1;
346 }
347
test_PACKET_get_length_prefixed_1(void)348 static int test_PACKET_get_length_prefixed_1(void)
349 {
350 unsigned char buf1[BUF_LEN];
351 const size_t len = 16;
352 unsigned int i;
353 PACKET pkt, short_pkt, subpkt;
354
355 memset(&subpkt, 0, sizeof(subpkt));
356 buf1[0] = (unsigned char)len;
357 for (i = 1; i < BUF_LEN; i++)
358 buf1[i] = (i * 2) & 0xff;
359
360 if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
361 || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
362 || !TEST_true(PACKET_get_length_prefixed_1(&pkt, &subpkt))
363 || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
364 || !TEST_true(PACKET_get_net_2(&subpkt, &i))
365 || !TEST_uint_eq(i, 0x0204)
366 || !TEST_false(PACKET_get_length_prefixed_1(&short_pkt, &subpkt))
367 || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
368 return 0;
369
370 return 1;
371 }
372
test_PACKET_get_length_prefixed_2(void)373 static int test_PACKET_get_length_prefixed_2(void)
374 {
375 unsigned char buf1[1024];
376 const size_t len = 516; /* 0x0204 */
377 unsigned int i;
378 PACKET pkt, short_pkt, subpkt;
379
380 memset(&subpkt, 0, sizeof(subpkt));
381 for (i = 1; i <= 1024; i++)
382 buf1[i - 1] = (i * 2) & 0xff;
383
384 if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
385 || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
386 || !TEST_true(PACKET_get_length_prefixed_2(&pkt, &subpkt))
387 || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
388 || !TEST_true(PACKET_get_net_2(&subpkt, &i))
389 || !TEST_uint_eq(i, 0x0608)
390 || !TEST_false(PACKET_get_length_prefixed_2(&short_pkt, &subpkt))
391 || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
392 return 0;
393
394 return 1;
395 }
396
test_PACKET_get_length_prefixed_3(void)397 static int test_PACKET_get_length_prefixed_3(void)
398 {
399 unsigned char buf1[1024];
400 const size_t len = 516; /* 0x000204 */
401 unsigned int i;
402 PACKET pkt, short_pkt, subpkt;
403
404 memset(&subpkt, 0, sizeof(subpkt));
405 for (i = 0; i < 1024; i++)
406 buf1[i] = (i * 2) & 0xff;
407
408 if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
409 || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
410 || !TEST_true(PACKET_get_length_prefixed_3(&pkt, &subpkt))
411 || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
412 || !TEST_true(PACKET_get_net_2(&subpkt, &i))
413 || !TEST_uint_eq(i, 0x0608)
414 || !TEST_false(PACKET_get_length_prefixed_3(&short_pkt, &subpkt))
415 || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
416 return 0;
417
418 return 1;
419 }
420
test_PACKET_as_length_prefixed_1(void)421 static int test_PACKET_as_length_prefixed_1(void)
422 {
423 unsigned char buf1[BUF_LEN];
424 const size_t len = 16;
425 unsigned int i;
426 PACKET pkt, exact_pkt, subpkt;
427
428 memset(&subpkt, 0, sizeof(subpkt));
429 buf1[0] = (unsigned char)len;
430 for (i = 1; i < BUF_LEN; i++)
431 buf1[i] = (i * 2) & 0xff;
432
433 if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
434 || !TEST_true(PACKET_buf_init(&exact_pkt, buf1, len + 1))
435 || !TEST_false(PACKET_as_length_prefixed_1(&pkt, &subpkt))
436 || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
437 || !TEST_true(PACKET_as_length_prefixed_1(&exact_pkt, &subpkt))
438 || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
439 || !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
440 return 0;
441
442 return 1;
443 }
444
test_PACKET_as_length_prefixed_2(void)445 static int test_PACKET_as_length_prefixed_2(void)
446 {
447 unsigned char buf[1024];
448 const size_t len = 516; /* 0x0204 */
449 unsigned int i;
450 PACKET pkt, exact_pkt, subpkt;
451
452 memset(&subpkt, 0, sizeof(subpkt));
453 for (i = 1; i <= 1024; i++)
454 buf[i-1] = (i * 2) & 0xff;
455
456 if (!TEST_true(PACKET_buf_init(&pkt, buf, 1024))
457 || !TEST_true(PACKET_buf_init(&exact_pkt, buf, len + 2))
458 || !TEST_false(PACKET_as_length_prefixed_2(&pkt, &subpkt))
459 || !TEST_size_t_eq(PACKET_remaining(&pkt), 1024)
460 || !TEST_true(PACKET_as_length_prefixed_2(&exact_pkt, &subpkt))
461 || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
462 || !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
463 return 0;
464
465 return 1;
466 }
467
468 #ifndef OPENSSL_NO_QUIC
469
test_PACKET_get_quic_vlint(void)470 static int test_PACKET_get_quic_vlint(void)
471 {
472 struct quic_test_case {
473 unsigned char buf[16];
474 size_t expected_read_count;
475 uint64_t value;
476 };
477
478 static const struct quic_test_case cases[] = {
479 { {0x00}, 1, 0 },
480 { {0x01}, 1, 1 },
481 { {0x3e}, 1, 62 },
482 { {0x3f}, 1, 63 },
483 { {0x40,0x00}, 2, 0 },
484 { {0x40,0x01}, 2, 1 },
485 { {0x40,0x02}, 2, 2 },
486 { {0x40,0xff}, 2, 255 },
487 { {0x41,0x00}, 2, 256 },
488 { {0x7f,0xfe}, 2, 16382 },
489 { {0x7f,0xff}, 2, 16383 },
490 { {0x80,0x00,0x00,0x00}, 4, 0 },
491 { {0x80,0x00,0x00,0x01}, 4, 1 },
492 { {0x80,0x00,0x01,0x02}, 4, 258 },
493 { {0x80,0x18,0x49,0x65}, 4, 1591653 },
494 { {0xbe,0x18,0x49,0x65}, 4, 1041779045 },
495 { {0xbf,0xff,0xff,0xff}, 4, 1073741823 },
496 { {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, 8, 0 },
497 { {0xc0,0x00,0x00,0x00,0x00,0x00,0x01,0x02}, 8, 258 },
498 { {0xfd,0x1f,0x59,0x8d,0xc9,0xf8,0x71,0x8a}, 8, 4404337426105397642 },
499 };
500
501 PACKET pkt;
502 size_t i;
503 uint64_t v;
504
505 for (i = 0; i < OSSL_NELEM(cases); ++i) {
506 memset(&pkt, 0, sizeof(pkt));
507 v = 55;
508
509 if (!TEST_true(PACKET_buf_init(&pkt, cases[i].buf, sizeof(cases[i].buf)))
510 || !TEST_true(PACKET_get_quic_vlint(&pkt, &v))
511 || !TEST_uint64_t_eq(v, cases[i].value)
512 || !TEST_size_t_eq(PACKET_remaining(&pkt),
513 sizeof(cases[i].buf) - cases[i].expected_read_count)
514 )
515 return 0;
516 }
517
518 return 1;
519 }
520
test_PACKET_get_quic_length_prefixed(void)521 static int test_PACKET_get_quic_length_prefixed(void)
522 {
523 struct quic_test_case {
524 unsigned char buf[16];
525 size_t enclen, len;
526 int fail;
527 };
528
529 static const struct quic_test_case cases[] = {
530 /* success cases */
531 { {0x00}, 1, 0, 0 },
532 { {0x01}, 1, 1, 0 },
533 { {0x02}, 1, 2, 0 },
534 { {0x03}, 1, 3, 0 },
535 { {0x04}, 1, 4, 0 },
536 { {0x05}, 1, 5, 0 },
537
538 /* failure cases */
539 { {0x10}, 1, 0, 1 },
540 { {0x3f}, 1, 0, 1 },
541 };
542
543 size_t i;
544 PACKET pkt, subpkt = {0};
545
546 for (i = 0; i < OSSL_NELEM(cases); ++i) {
547 memset(&pkt, 0, sizeof(pkt));
548
549 if (!TEST_true(PACKET_buf_init(&pkt, cases[i].buf,
550 cases[i].fail
551 ? sizeof(cases[i].buf)
552 : cases[i].enclen + cases[i].len)))
553 return 0;
554
555 if (!TEST_int_eq(PACKET_get_quic_length_prefixed(&pkt, &subpkt), !cases[i].fail))
556 return 0;
557
558 if (cases[i].fail) {
559 if (!TEST_ptr_eq(pkt.curr, cases[i].buf))
560 return 0;
561 continue;
562 }
563
564 if (!TEST_ptr_eq(subpkt.curr, cases[i].buf + cases[i].enclen))
565 return 0;
566
567 if (!TEST_size_t_eq(subpkt.remaining, cases[i].len))
568 return 0;
569 }
570
571 return 1;
572 }
573
574 #endif
575
setup_tests(void)576 int setup_tests(void)
577 {
578 unsigned int i;
579
580 for (i = 1; i <= BUF_LEN; i++)
581 smbuf[i - 1] = (i * 2) & 0xff;
582
583 ADD_TEST(test_PACKET_buf_init);
584 ADD_TEST(test_PACKET_null_init);
585 ADD_TEST(test_PACKET_remaining);
586 ADD_TEST(test_PACKET_end);
587 ADD_TEST(test_PACKET_equal);
588 ADD_TEST(test_PACKET_get_1);
589 ADD_TEST(test_PACKET_get_4);
590 ADD_TEST(test_PACKET_get_net_2);
591 ADD_TEST(test_PACKET_get_net_3);
592 ADD_TEST(test_PACKET_get_net_4);
593 ADD_TEST(test_PACKET_get_sub_packet);
594 ADD_TEST(test_PACKET_get_bytes);
595 ADD_TEST(test_PACKET_copy_bytes);
596 ADD_TEST(test_PACKET_copy_all);
597 ADD_TEST(test_PACKET_memdup);
598 ADD_TEST(test_PACKET_strndup);
599 ADD_TEST(test_PACKET_contains_zero_byte);
600 ADD_TEST(test_PACKET_forward);
601 ADD_TEST(test_PACKET_get_length_prefixed_1);
602 ADD_TEST(test_PACKET_get_length_prefixed_2);
603 ADD_TEST(test_PACKET_get_length_prefixed_3);
604 ADD_TEST(test_PACKET_as_length_prefixed_1);
605 ADD_TEST(test_PACKET_as_length_prefixed_2);
606 #ifndef OPENSSL_NO_QUIC
607 ADD_TEST(test_PACKET_get_quic_vlint);
608 ADD_TEST(test_PACKET_get_quic_length_prefixed);
609 #endif
610 return 1;
611 }
612
