1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <assert.h>
5 #include "checksum_test_ref.h"
6 #include "igzip_lib.h"
7 #include "igzip_wrapper.h"
8
9 #ifndef TEST_SEED
10 #define TEST_SEED 0x1234
11 #endif
12 #ifndef RANDOMS
13 #define RANDOMS 0x4000
14 #endif
15
16 #define EXTRA_SIZE_MAX 256
17 #define NAME_SIZE_MAX 256
18 #define COMMENT_SIZE_MAX 1024
19
20 #define EXTRA_SIZE 10
21 #define NAME_SIZE 25
22 #define COMMENT_SIZE 192
23
24 enum {
25 INVALID_WRAPPER = ISAL_INVALID_WRAPPER,
26 UNSUPPORTED_METHOD = ISAL_UNSUPPORTED_METHOD,
27 INCORRECT_CHECKSUM = ISAL_INCORRECT_CHECKSUM,
28 NO_ERROR = ISAL_DECOMP_OK,
29 END_INPUT = ISAL_END_INPUT,
30 NAME_OVERFLOW = ISAL_NAME_OVERFLOW,
31 COMMENT_OVERFLOW = ISAL_COMMENT_OVERFLOW,
32 EXTRA_OVERFLOW = ISAL_EXTRA_OVERFLOW,
33 INCORRECT_TEXT_FLAG,
34 INCORRECT_TIME,
35 INCORRECT_XFLAGS,
36 INCORRECT_OS,
37 INCORRECT_EXTRA_LEN,
38 INCORRECT_EXTRA_BUF,
39 INCORRECT_NAME,
40 INCORRECT_COMMENT,
41 INCORRECT_INFO,
42 INCORRECT_LEVEL,
43 INCORRECT_DICT_FLAG,
44 INCORRECT_DICT_ID,
45 INCORRECT_HDR_LEN,
46 INSUFFICIENT_BUFFER_SIZE,
47 INCORRECT_WRITE_RETURN,
48 MALLOC_FAILED
49 };
50
51 void
print_error(int32_t error)52 print_error(int32_t error)
53 {
54 printf("Error Code %d: ", error);
55 switch (error) {
56 case END_INPUT:
57 printf("End of input reached before header decompressed\n");
58 break;
59 case INVALID_WRAPPER:
60 printf("Invalid gzip wrapper found\n");
61 break;
62 case UNSUPPORTED_METHOD:
63 printf("Unsupported decompression method found\n");
64 break;
65 case INCORRECT_CHECKSUM:
66 printf("Incorrect header checksum found\n");
67 break;
68 case NAME_OVERFLOW:
69 printf("Name buffer overflow while decompression\n");
70 break;
71 case COMMENT_OVERFLOW:
72 printf("Comment buffer overflow while decompressing\n");
73 break;
74 case EXTRA_OVERFLOW:
75 printf("Extra buffer overflow while decomrpessiong\n");
76 break;
77 case INCORRECT_TEXT_FLAG:
78 printf("Incorrect text field found\n");
79 break;
80 case INCORRECT_TIME:
81 printf("Incorrect time filed found\n");
82 break;
83 case INCORRECT_XFLAGS:
84 printf("Incorrect xflags field found\n");
85 break;
86 case INCORRECT_OS:
87 printf("Incorrect os field found\n");
88 break;
89 case INCORRECT_EXTRA_LEN:
90 printf("Incorrect extra_len field found\n");
91 break;
92 case INCORRECT_EXTRA_BUF:
93 printf("Incorrect extra buffer found\n");
94 break;
95 case INCORRECT_NAME:
96 printf("Incorrect name found\n");
97 break;
98 case INCORRECT_COMMENT:
99 printf("Incorrect comment found\n");
100 break;
101 case INCORRECT_INFO:
102 printf("Incorrect info found\n");
103 break;
104 case INCORRECT_LEVEL:
105 printf("Incorrect level found\n");
106 break;
107 case INCORRECT_DICT_FLAG:
108 printf("Incorrect dictionary flag found\n");
109 break;
110 case INCORRECT_DICT_ID:
111 printf("Incorrect dictionary id found\n");
112 break;
113 case INCORRECT_HDR_LEN:
114 printf("Incorrect header length found\n");
115 break;
116 case INSUFFICIENT_BUFFER_SIZE:
117 printf("Insufficient buffer size to write header\n");
118 break;
119 case INCORRECT_WRITE_RETURN:
120 printf("Header write returned an incorrect value\n");
121 break;
122 case MALLOC_FAILED:
123 printf("Failed to allocate buffers\n");
124 break;
125 case NO_ERROR:
126 printf("No error found\n");
127 }
128 }
129
130 void
print_uint8_t(uint8_t * array,uint64_t length,char * prepend)131 print_uint8_t(uint8_t *array, uint64_t length, char *prepend)
132 {
133 const int line_size = 16;
134 int i;
135
136 if (array == NULL) {
137 printf("%s(NULL)\n", prepend);
138 return;
139 } else if (length == 0) {
140 printf("%s(Empty)\n", prepend);
141 return;
142 }
143
144 for (i = 0; i < length; i++) {
145 if (i == 0)
146 printf("%s0x%04x\t", prepend, i);
147 else if ((i % line_size) == 0)
148 printf("\n%s0x%04x\t", prepend, i);
149 else
150 printf(" ");
151 printf("0x%02x,", array[i]);
152 }
153 printf("\n");
154 }
155
156 void
print_string(char * str,uint32_t str_max_len,char * prepend)157 print_string(char *str, uint32_t str_max_len, char *prepend)
158 {
159 const int line_size = 64;
160 uint32_t i = 0;
161
162 while (str[i] != 0 && i < str_max_len) {
163 if (i == 0)
164 printf("%s0x%04x\t", prepend, i);
165 else if ((i % line_size) == 0)
166 printf("\n%s0x%04x\t", prepend, i);
167
168 printf("%c", str[i]);
169 i++;
170 }
171 printf("\n");
172 }
173
174 void
print_gzip_header(struct isal_gzip_header * gz_hdr,char * prepend1,char * prepend2)175 print_gzip_header(struct isal_gzip_header *gz_hdr, char *prepend1, char *prepend2)
176 {
177 printf("%sText: %d, Time: 0x%08x, Xflags: 0x%x, OS: 0x%x\n", prepend1, gz_hdr->text,
178 gz_hdr->time, gz_hdr->xflags, gz_hdr->os);
179
180 printf("%sExtra: Extra_len = 0x%x\n", prepend1, gz_hdr->extra_len);
181 if (gz_hdr->extra_len < EXTRA_SIZE_MAX)
182 print_uint8_t(gz_hdr->extra, gz_hdr->extra_len, prepend2);
183 else
184 printf("%sExtra field larger than EXTRA_SIZE_MAX\n", prepend2);
185
186 printf("%sName:\n", prepend1);
187 if (gz_hdr->name_buf_len < NAME_SIZE_MAX)
188 print_string(gz_hdr->name, gz_hdr->name_buf_len, prepend2);
189 else
190 printf("%sName field larger than NAME_SIZE_MAX\n", prepend2);
191
192 printf("%sComment:\n", prepend1);
193 if (gz_hdr->comment_buf_len < COMMENT_SIZE_MAX)
194 print_string(gz_hdr->comment, gz_hdr->comment_buf_len, prepend2);
195 else
196 printf("%sComment field larger than COMMENT_SIZE_MAX\n", prepend2);
197 }
198
199 void
print_zlib_header(struct isal_zlib_header * z_hdr,char * prepend)200 print_zlib_header(struct isal_zlib_header *z_hdr, char *prepend)
201 {
202 printf("%sInfo: 0x%x\n", prepend, z_hdr->info);
203 printf("%sLevel: 0x%x\n", prepend, z_hdr->level);
204 printf("%sDictionary: Flag = 0x%x, Id =0x%x\n", prepend, z_hdr->dict_flag, z_hdr->dict_id);
205 }
206
207 void
print_gzip_final_verbose(uint8_t * hdr_buf,uint32_t hdr_buf_len,struct isal_gzip_header * gz_hdr_orig,struct isal_gzip_header * gz_hdr)208 print_gzip_final_verbose(uint8_t *hdr_buf, uint32_t hdr_buf_len,
209 struct isal_gzip_header *gz_hdr_orig, struct isal_gzip_header *gz_hdr)
210 {
211 #ifdef VERBOSE
212 printf("\n");
213 if (gz_hdr_orig != NULL) {
214 printf("Original Gzip Header Struct:\n");
215 print_gzip_header(gz_hdr_orig, "\t", "\t\t");
216 printf("\n");
217 }
218
219 if (gz_hdr != NULL) {
220 printf("Parsed Gzip Header Struct:\n");
221 print_gzip_header(gz_hdr, "\t", "\t\t");
222 printf("\n");
223 }
224
225 if (hdr_buf != NULL) {
226 printf("Serialized Gzip Header:\n");
227 print_uint8_t(hdr_buf, hdr_buf_len, "\t");
228 printf("\n");
229 }
230 #endif
231 return;
232 }
233
234 void
print_zlib_final_verbose(uint8_t * hdr_buf,uint32_t hdr_buf_len,struct isal_zlib_header * z_hdr_orig,struct isal_zlib_header * z_hdr)235 print_zlib_final_verbose(uint8_t *hdr_buf, uint32_t hdr_buf_len,
236 struct isal_zlib_header *z_hdr_orig, struct isal_zlib_header *z_hdr)
237 {
238 #ifdef VERBOSE
239 printf("\n");
240 if (z_hdr_orig != NULL) {
241 printf("Original Zlib Header Struct:\n");
242 print_zlib_header(z_hdr_orig, "\t");
243 printf("\n");
244 }
245
246 if (z_hdr != NULL) {
247 printf("Parsed Zlib Header Struct:\n");
248 print_zlib_header(z_hdr, "\t");
249 printf("\n");
250 }
251
252 if (hdr_buf != NULL) {
253 printf("Serialized Zlib Header:\n");
254 print_uint8_t(hdr_buf, hdr_buf_len, "\t");
255 printf("\n");
256 }
257 #endif
258 return;
259 }
260
261 int
gzip_header_size(struct isal_gzip_header * gz_hdr)262 gzip_header_size(struct isal_gzip_header *gz_hdr)
263 {
264 int hdr_size = 10;
265 if (gz_hdr->extra != NULL) {
266 hdr_size += 2 + gz_hdr->extra_len;
267 }
268 if (gz_hdr->name != NULL) {
269 hdr_size += strnlen(gz_hdr->name, gz_hdr->name_buf_len) + 1;
270 }
271 if (gz_hdr->comment != NULL) {
272 hdr_size += strnlen(gz_hdr->comment, gz_hdr->comment_buf_len) + 1;
273 }
274
275 if (gz_hdr->hcrc) {
276 hdr_size += 2;
277 }
278
279 return hdr_size;
280 }
281
282 int
zlib_header_size(struct isal_zlib_header * z_hdr)283 zlib_header_size(struct isal_zlib_header *z_hdr)
284 {
285 if (z_hdr->dict_flag)
286 return 6;
287 else
288 return 2;
289 }
290
291 void
rand_string(char * string,uint32_t str_len)292 rand_string(char *string, uint32_t str_len)
293 {
294 int i;
295
296 if (str_len == 0 || string == NULL)
297 return;
298 for (i = 0; i < str_len - 1; i++) {
299 string[i] = rand() % 26 + 65;
300 }
301 string[str_len - 1] = 0;
302 }
303
304 void
rand_buf(uint8_t * buf,uint32_t buf_len)305 rand_buf(uint8_t *buf, uint32_t buf_len)
306 {
307 int i;
308
309 if (buf_len == 0 || buf == NULL)
310 return;
311
312 for (i = 0; i < buf_len; i++) {
313 buf[i] = rand();
314 }
315 }
316
317 int
malloc_gzip_header(struct isal_gzip_header * gz_hdr)318 malloc_gzip_header(struct isal_gzip_header *gz_hdr)
319 {
320 gz_hdr->extra = NULL;
321 if (gz_hdr->extra_buf_len) {
322 gz_hdr->extra = malloc(gz_hdr->extra_buf_len);
323 if (gz_hdr->extra == NULL)
324 return MALLOC_FAILED;
325 }
326
327 gz_hdr->name = NULL;
328 if (gz_hdr->name_buf_len) {
329 gz_hdr->name = malloc(gz_hdr->name_buf_len);
330 if (gz_hdr->name == NULL) {
331 free(gz_hdr->extra);
332 return MALLOC_FAILED;
333 }
334 }
335
336 gz_hdr->comment = NULL;
337 if (gz_hdr->comment_buf_len) {
338 gz_hdr->comment = malloc(gz_hdr->comment_buf_len);
339 if (gz_hdr->comment == NULL) {
340 free(gz_hdr->extra);
341 free(gz_hdr->name);
342 return MALLOC_FAILED;
343 }
344 }
345
346 return 0;
347 }
348
349 void
free_gzip_header(struct isal_gzip_header * gz_hdr)350 free_gzip_header(struct isal_gzip_header *gz_hdr)
351 {
352 if (gz_hdr->extra != NULL) {
353 free(gz_hdr->extra);
354 gz_hdr->extra = NULL;
355 }
356
357 if (gz_hdr->name != NULL) {
358 free(gz_hdr->name);
359 gz_hdr->name = NULL;
360 }
361
362 if (gz_hdr->comment != NULL) {
363 free(gz_hdr->comment);
364 gz_hdr->comment = NULL;
365 }
366 }
367
368 int
gen_rand_gzip_header(struct isal_gzip_header * gz_hdr)369 gen_rand_gzip_header(struct isal_gzip_header *gz_hdr)
370 {
371 int ret = 0;
372 int field_set_space = 8;
373
374 isal_gzip_header_init(gz_hdr);
375
376 if (rand() % field_set_space != 0)
377 gz_hdr->text = rand() % 2;
378 if (rand() % field_set_space != 0)
379 gz_hdr->time = rand();
380 if (rand() % field_set_space != 0)
381 gz_hdr->xflags = rand() % 256;
382 if (rand() % field_set_space != 0)
383 gz_hdr->os = rand() % 256;
384
385 if (rand() % field_set_space != 0) {
386 gz_hdr->extra_buf_len = rand() % EXTRA_SIZE_MAX;
387 gz_hdr->extra_len = gz_hdr->extra_buf_len;
388 }
389
390 if (rand() % field_set_space != 0)
391 gz_hdr->name_buf_len = rand() % NAME_SIZE_MAX;
392
393 if (rand() % field_set_space != 0)
394 gz_hdr->comment_buf_len = rand() % COMMENT_SIZE_MAX;
395
396 gz_hdr->hcrc = rand() % 2;
397
398 ret = malloc_gzip_header(gz_hdr);
399 if (ret)
400 return ret;
401
402 rand_buf(gz_hdr->extra, gz_hdr->extra_len);
403 rand_string(gz_hdr->name, gz_hdr->name_buf_len);
404 rand_string(gz_hdr->comment, gz_hdr->comment_buf_len);
405
406 return ret;
407 }
408
409 void
gen_rand_zlib_header(struct isal_zlib_header * z_hdr)410 gen_rand_zlib_header(struct isal_zlib_header *z_hdr)
411 {
412 z_hdr->info = rand() % 16;
413 z_hdr->level = rand() % 4;
414 z_hdr->dict_flag = rand() % 2;
415 z_hdr->dict_id = rand();
416 }
417
418 int
write_gzip_header(uint8_t * hdr_buf,uint32_t hdr_buf_len,struct isal_gzip_header * gz_hdr)419 write_gzip_header(uint8_t *hdr_buf, uint32_t hdr_buf_len, struct isal_gzip_header *gz_hdr)
420 {
421
422 struct isal_zstream stream;
423 uint32_t hdr_len = gzip_header_size(gz_hdr);
424 uint32_t len;
425
426 isal_deflate_init(&stream);
427 stream.next_out = hdr_buf;
428 stream.avail_out = rand() % hdr_len;
429 len = isal_write_gzip_header(&stream, gz_hdr);
430
431 if (len != hdr_len) {
432 printf("len = %d, hdr_buf_len = %d\n", len, hdr_len);
433 print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr, NULL);
434 print_error(INCORRECT_HDR_LEN);
435 return INCORRECT_HDR_LEN;
436 }
437
438 if (hdr_buf_len < hdr_len) {
439 print_gzip_final_verbose(NULL, 0, gz_hdr, NULL);
440 print_error(INSUFFICIENT_BUFFER_SIZE);
441 return INSUFFICIENT_BUFFER_SIZE;
442 }
443
444 stream.avail_out = hdr_buf_len;
445
446 len = isal_write_gzip_header(&stream, gz_hdr);
447
448 if (len) {
449 print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr, NULL);
450 print_error(INCORRECT_WRITE_RETURN);
451 return INCORRECT_WRITE_RETURN;
452 ;
453 }
454
455 return 0;
456 }
457
458 int
write_zlib_header(uint8_t * hdr_buf,uint32_t hdr_buf_len,struct isal_zlib_header * z_hdr)459 write_zlib_header(uint8_t *hdr_buf, uint32_t hdr_buf_len, struct isal_zlib_header *z_hdr)
460 {
461 struct isal_zstream stream;
462 uint32_t hdr_len = zlib_header_size(z_hdr);
463 uint32_t len;
464
465 isal_deflate_init(&stream);
466 stream.next_out = hdr_buf;
467 stream.avail_out = rand() % hdr_len;
468 len = isal_write_zlib_header(&stream, z_hdr);
469
470 if (len != hdr_len) {
471 print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr, NULL);
472 print_error(INCORRECT_HDR_LEN);
473 return INCORRECT_HDR_LEN;
474 }
475
476 if (hdr_buf_len < hdr_len) {
477 print_zlib_final_verbose(NULL, 0, z_hdr, NULL);
478 print_error(INSUFFICIENT_BUFFER_SIZE);
479 return INSUFFICIENT_BUFFER_SIZE;
480 }
481
482 stream.avail_out = hdr_buf_len;
483
484 len = isal_write_zlib_header(&stream, z_hdr);
485
486 if (len) {
487 print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr, NULL);
488 print_error(INCORRECT_WRITE_RETURN);
489 return INCORRECT_WRITE_RETURN;
490 ;
491 }
492
493 return 0;
494 }
495
496 int
compare_gzip_headers(struct isal_gzip_header * gz_hdr1,struct isal_gzip_header * gz_hdr2)497 compare_gzip_headers(struct isal_gzip_header *gz_hdr1, struct isal_gzip_header *gz_hdr2)
498 {
499 int ret = 0;
500 uint32_t max_len;
501
502 if (gz_hdr1->text != gz_hdr2->text)
503 return INCORRECT_TEXT_FLAG;
504
505 if (gz_hdr1->time != gz_hdr2->time)
506 return INCORRECT_TIME;
507
508 if (gz_hdr1->xflags != gz_hdr2->xflags)
509 return INCORRECT_XFLAGS;
510
511 if (gz_hdr1->os != gz_hdr2->os)
512 return INCORRECT_OS;
513
514 if (gz_hdr1->extra_len != gz_hdr2->extra_len)
515 return INCORRECT_EXTRA_LEN;
516
517 if (gz_hdr1->extra != NULL && gz_hdr2->extra != NULL) {
518 ret = memcmp(gz_hdr1->extra, gz_hdr2->extra, gz_hdr1->extra_len);
519 if (ret)
520 return INCORRECT_EXTRA_BUF;
521 }
522
523 if (gz_hdr1->name != NULL && gz_hdr2->name != NULL) {
524 max_len = gz_hdr1->name_buf_len;
525 if (gz_hdr1->name_buf_len < gz_hdr2->name_buf_len)
526 max_len = gz_hdr2->name_buf_len;
527
528 ret = strncmp(gz_hdr1->name, gz_hdr2->name, max_len);
529 if (ret)
530 return INCORRECT_NAME;
531 }
532
533 if (gz_hdr1->comment != NULL && gz_hdr2->comment != NULL) {
534 max_len = gz_hdr1->comment_buf_len;
535 if (gz_hdr1->comment_buf_len < gz_hdr2->comment_buf_len)
536 max_len = gz_hdr2->comment_buf_len;
537
538 ret = strncmp(gz_hdr1->comment, gz_hdr2->comment, max_len);
539 if (ret)
540 return INCORRECT_COMMENT;
541 }
542 return ret;
543 }
544
545 int
compare_zlib_headers(struct isal_zlib_header * z_hdr1,struct isal_zlib_header * z_hdr2)546 compare_zlib_headers(struct isal_zlib_header *z_hdr1, struct isal_zlib_header *z_hdr2)
547 {
548 if (z_hdr1->info != z_hdr2->info)
549 return INCORRECT_INFO;
550
551 if (z_hdr1->level != z_hdr2->level)
552 return INCORRECT_LEVEL;
553
554 if (z_hdr1->dict_flag != z_hdr2->dict_flag)
555 return INCORRECT_DICT_FLAG;
556
557 if (z_hdr1->dict_flag && z_hdr1->dict_id != z_hdr2->dict_id)
558 return INCORRECT_DICT_ID;
559
560 return 0;
561 }
562
563 int
read_gzip_header_simple(uint8_t * hdr_buf,uint32_t hdr_buf_len,struct isal_gzip_header * gz_hdr_orig)564 read_gzip_header_simple(uint8_t *hdr_buf, uint32_t hdr_buf_len,
565 struct isal_gzip_header *gz_hdr_orig)
566 {
567
568 int ret = 0;
569 struct inflate_state state;
570 struct isal_gzip_header gz_hdr;
571
572 rand_buf((uint8_t *) &gz_hdr, sizeof(gz_hdr));
573 gz_hdr.extra_buf_len = gz_hdr_orig->extra_buf_len;
574 gz_hdr.name_buf_len = gz_hdr_orig->name_buf_len;
575 gz_hdr.comment_buf_len = gz_hdr_orig->comment_buf_len;
576
577 ret = malloc_gzip_header(&gz_hdr);
578 if (ret) {
579 print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, NULL);
580 print_error(ret);
581 free_gzip_header(&gz_hdr);
582 return ret;
583 }
584
585 isal_inflate_init(&state);
586 state.next_in = hdr_buf;
587 state.avail_in = hdr_buf_len;
588 ret = isal_read_gzip_header(&state, &gz_hdr);
589
590 if (ret) {
591 print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, &gz_hdr);
592 print_error(ret);
593 free_gzip_header(&gz_hdr);
594 return ret;
595 }
596
597 ret = compare_gzip_headers(gz_hdr_orig, &gz_hdr);
598
599 if (ret) {
600 print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, &gz_hdr);
601 print_error(ret);
602 }
603
604 free_gzip_header(&gz_hdr);
605 return ret;
606 }
607
608 int
read_zlib_header_simple(uint8_t * hdr_buf,uint32_t hdr_buf_len,struct isal_zlib_header * z_hdr_orig)609 read_zlib_header_simple(uint8_t *hdr_buf, uint32_t hdr_buf_len, struct isal_zlib_header *z_hdr_orig)
610 {
611
612 int ret = 0;
613 struct inflate_state state;
614 struct isal_zlib_header z_hdr;
615
616 rand_buf((uint8_t *) &z_hdr, sizeof(z_hdr));
617
618 isal_inflate_init(&state);
619 state.next_in = hdr_buf;
620 state.avail_in = hdr_buf_len;
621 ret = isal_read_zlib_header(&state, &z_hdr);
622
623 if (ret) {
624 print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr_orig, &z_hdr);
625 print_error(ret);
626 return ret;
627 }
628
629 ret = compare_zlib_headers(z_hdr_orig, &z_hdr);
630
631 if (ret) {
632 print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr_orig, &z_hdr);
633 print_error(ret);
634 }
635
636 return ret;
637 }
638
639 int
read_gzip_header_streaming(uint8_t * hdr_buf,uint32_t hdr_buf_len,struct isal_gzip_header * gz_hdr_orig)640 read_gzip_header_streaming(uint8_t *hdr_buf, uint32_t hdr_buf_len,
641 struct isal_gzip_header *gz_hdr_orig)
642 {
643 int ret = 0;
644 uint32_t max_dec_size, dec_size, max_extra_len, extra_len;
645 uint32_t max_name_len, name_len, max_comment_len, comment_len;
646 struct inflate_state state;
647 struct isal_gzip_header gz_hdr;
648 void *tmp_ptr;
649
650 rand_buf((uint8_t *) &gz_hdr, sizeof(gz_hdr));
651
652 max_dec_size = (rand() % hdr_buf_len) + 2;
653
654 max_extra_len = 2;
655 max_name_len = 2;
656 max_comment_len = 2;
657 if (gz_hdr_orig->extra_buf_len)
658 max_extra_len = (rand() % gz_hdr_orig->extra_buf_len) + 2;
659 if (gz_hdr_orig->name_buf_len)
660 max_name_len = (rand() % gz_hdr_orig->name_buf_len) + 2;
661 if (gz_hdr_orig->comment_buf_len)
662 max_comment_len = (rand() % gz_hdr_orig->comment_buf_len) + 2;
663
664 extra_len = rand() % max_extra_len;
665 name_len = rand() % max_name_len;
666 comment_len = rand() % max_comment_len;
667
668 if (extra_len == 0)
669 extra_len = 1;
670 if (name_len == 0)
671 name_len = 1;
672 if (comment_len == 0)
673 comment_len = 1;
674
675 gz_hdr.extra_buf_len = extra_len;
676 gz_hdr.name_buf_len = name_len;
677 gz_hdr.comment_buf_len = comment_len;
678
679 ret = malloc_gzip_header(&gz_hdr);
680
681 if (ret) {
682 print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, NULL);
683 print_error(ret);
684 free_gzip_header(&gz_hdr);
685 return (ret == 0);
686 }
687
688 isal_inflate_init(&state);
689
690 state.next_in = hdr_buf;
691 dec_size = rand() % max_dec_size;
692 if (dec_size > hdr_buf_len)
693 dec_size = hdr_buf_len;
694
695 state.avail_in = dec_size;
696 hdr_buf_len -= dec_size;
697
698 while (1) {
699 ret = isal_read_gzip_header(&state, &gz_hdr);
700
701 switch (ret) {
702 case ISAL_NAME_OVERFLOW:
703 if (name_len >= NAME_SIZE_MAX)
704 break;
705
706 name_len += rand() % max_name_len;
707 tmp_ptr = realloc(gz_hdr.name, name_len);
708 if (tmp_ptr == NULL) {
709 ret = MALLOC_FAILED;
710 break;
711 }
712 gz_hdr.name = tmp_ptr;
713 gz_hdr.name_buf_len = name_len;
714 continue;
715 case ISAL_COMMENT_OVERFLOW:
716 if (comment_len >= COMMENT_SIZE_MAX)
717 break;
718
719 comment_len += rand() % max_comment_len;
720 tmp_ptr = realloc(gz_hdr.comment, comment_len);
721 if (tmp_ptr == NULL) {
722 ret = MALLOC_FAILED;
723 break;
724 }
725 gz_hdr.comment = tmp_ptr;
726 gz_hdr.comment_buf_len = comment_len;
727 continue;
728 case ISAL_EXTRA_OVERFLOW:
729 if (extra_len >= EXTRA_SIZE_MAX)
730 break;
731
732 extra_len += rand() % max_extra_len;
733 tmp_ptr = realloc(gz_hdr.extra, extra_len);
734 if (tmp_ptr == NULL) {
735 ret = MALLOC_FAILED;
736 break;
737 }
738 gz_hdr.extra = tmp_ptr;
739 gz_hdr.extra_buf_len = extra_len;
740 continue;
741 case ISAL_END_INPUT:
742 if (hdr_buf_len == 0)
743 break;
744
745 dec_size = rand() % max_dec_size;
746 if (dec_size > hdr_buf_len)
747 dec_size = hdr_buf_len;
748
749 state.avail_in = dec_size;
750 hdr_buf_len -= dec_size;
751 continue;
752 }
753
754 break;
755 }
756
757 if (ret) {
758 print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, &gz_hdr);
759 print_error(ret);
760 free_gzip_header(&gz_hdr);
761 return ret;
762 }
763
764 ret = compare_gzip_headers(gz_hdr_orig, &gz_hdr);
765
766 if (ret) {
767 print_gzip_final_verbose(hdr_buf, hdr_buf_len, gz_hdr_orig, &gz_hdr);
768 print_error(ret);
769 }
770
771 free_gzip_header(&gz_hdr);
772 return ret;
773 }
774
775 int
read_zlib_header_streaming(uint8_t * hdr_buf,uint32_t hdr_buf_len,struct isal_zlib_header * z_hdr_orig)776 read_zlib_header_streaming(uint8_t *hdr_buf, uint32_t hdr_buf_len,
777 struct isal_zlib_header *z_hdr_orig)
778 {
779 int ret = ISAL_END_INPUT;
780 uint32_t max_dec_size, dec_size;
781 struct inflate_state state;
782 struct isal_zlib_header z_hdr;
783
784 rand_buf((uint8_t *) &z_hdr, sizeof(z_hdr));
785
786 max_dec_size = (rand() % hdr_buf_len) + 2;
787
788 isal_inflate_init(&state);
789
790 state.next_in = hdr_buf;
791 while (ret == ISAL_END_INPUT && hdr_buf_len > 0) {
792 dec_size = rand() % max_dec_size;
793 if (dec_size > hdr_buf_len)
794 dec_size = hdr_buf_len;
795
796 state.avail_in = dec_size;
797 hdr_buf_len -= dec_size;
798
799 ret = isal_read_zlib_header(&state, &z_hdr);
800 }
801
802 if (ret) {
803 print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr_orig, &z_hdr);
804 print_error(ret);
805 return ret;
806 }
807
808 ret = compare_zlib_headers(z_hdr_orig, &z_hdr);
809
810 if (ret) {
811 print_zlib_final_verbose(hdr_buf, hdr_buf_len, z_hdr_orig, &z_hdr);
812 print_error(ret);
813 }
814
815 return ret;
816 }
817
818 int
main(int argc,char * argv[])819 main(int argc, char *argv[])
820 {
821 uint8_t *hdr_buf = NULL;
822 uint32_t hdr_buf_len;
823 int ret = 0;
824 struct isal_gzip_header gz_hdr_orig;
825 struct isal_zlib_header z_hdr_orig;
826 int i;
827
828 #ifndef VERBOSE
829 setbuf(stdout, NULL);
830 #endif
831 printf("Test Seed : %d\n", TEST_SEED);
832 printf("Randoms : %d\n", RANDOMS);
833 srand(TEST_SEED);
834
835 printf("gzip wrapper test: ");
836 for (i = 0; i < RANDOMS; i++) {
837 rand_buf((uint8_t *) &gz_hdr_orig, sizeof(gz_hdr_orig));
838
839 ret = gen_rand_gzip_header(&gz_hdr_orig);
840 if (ret) {
841 print_error(ret);
842 goto exit;
843 }
844
845 hdr_buf_len = gzip_header_size(&gz_hdr_orig);
846 hdr_buf = malloc(hdr_buf_len);
847 if (hdr_buf == NULL) {
848 printf("alloc error: Fail");
849 ret = 1;
850 goto exit;
851 }
852
853 ret = write_gzip_header(hdr_buf, hdr_buf_len, &gz_hdr_orig);
854
855 if (ret)
856 goto exit;
857
858 ret = read_gzip_header_simple(hdr_buf, hdr_buf_len, &gz_hdr_orig);
859
860 if (ret)
861 goto exit;
862
863 ret = read_gzip_header_streaming(hdr_buf, hdr_buf_len, &gz_hdr_orig);
864
865 if (ret)
866 goto exit;
867
868 free_gzip_header(&gz_hdr_orig);
869 free(hdr_buf);
870 hdr_buf = NULL;
871 #ifdef TEST_VERBOSE
872 if (i % (RANDOMS / 16) == 0)
873 printf(".");
874 #endif
875 }
876 printf("Pass \n");
877
878 printf("zlib wrapper test: ");
879 for (i = 0; i < RANDOMS; i++) {
880 isal_zlib_header_init(&z_hdr_orig);
881
882 gen_rand_zlib_header(&z_hdr_orig);
883
884 hdr_buf_len = zlib_header_size(&z_hdr_orig);
885 hdr_buf = malloc(hdr_buf_len);
886 if (hdr_buf == NULL) {
887 printf("alloc error: Fail\n");
888 ret = 1;
889 goto exit;
890 }
891
892 ret = write_zlib_header(hdr_buf, hdr_buf_len, &z_hdr_orig);
893
894 if (ret)
895 goto exit;
896
897 ret = read_zlib_header_simple(hdr_buf, hdr_buf_len, &z_hdr_orig);
898
899 if (ret)
900 goto exit;
901
902 ret = read_zlib_header_streaming(hdr_buf, hdr_buf_len, &z_hdr_orig);
903
904 if (ret)
905 goto exit;
906
907 free(hdr_buf);
908 hdr_buf = NULL;
909 #ifdef TEST_VERBOSE
910 if (i % (RANDOMS / 16) == 0)
911 printf(".");
912 #endif
913 }
914 printf("Pass \n");
915
916 printf("igzip wrapper_hdr test finished: All tests passed \n");
917
918 ret = 0;
919 exit:
920 if (hdr_buf != NULL)
921 free(hdr_buf);
922
923 return ret;
924 }
925