Geant4 Cross Reference |
1 /* inflate.c -- zlib decompression 1 2 * Copyright (C) 1995-2022 Mark Adler 3 * For conditions of distribution and use, see 4 */ 5 6 /* 7 * Change history: 8 * 9 * 1.2.beta0 24 Nov 2002 10 * - First version -- complete rewrite of infl 11 * creation of window when not needed, minim 12 * needed, make inffast.c even faster, imple 13 * improve code readability and style over t 14 * 15 * 1.2.beta1 25 Nov 2002 16 * - Use pointers for available input and outp 17 * - Remove input and output counters in inffa 18 * - Change inffast.c entry and loop from avai 19 * - Remove unnecessary second byte pull from 20 * - Unroll direct copy to three copies per lo 21 * 22 * 1.2.beta2 4 Dec 2002 23 * - Change external routine names to reduce p 24 * - Correct filename to inffixed.h for fixed 25 * - Make hbuf[] unsigned char to match parame 26 * - Change strm->next_out[-state->offset] to 27 * to avoid negation problem on Alphas (64 b 28 * 29 * 1.2.beta3 22 Dec 2002 30 * - Add comments on state->bits assertion in 31 * - Add comments on op field in inftrees.h 32 * - Fix bug in reuse of allocated window afte 33 * - Remove bit fields--back to byte structure 34 * - Remove distance extra == 0 check in infla 35 * - Change post-increments to pre-increments 36 * - Add compile time option, POSTINC, to use 37 * - Make MATCH copy in inflate() much faster 38 * - Use local copies of stream next and avail 39 * buffer and bit count in inflate()--for sp 40 * 41 * 1.2.beta4 1 Jan 2003 42 * - Split ptr - 257 statements in inflate_tab 43 * - Move a comment on output buffer sizes fro 44 * - Add comments in inffast.c to introduce th 45 * - Rearrange window copies in inflate_fast() 46 * - Unroll last copy for window match in infl 47 * - Use local copies of window variables in i 48 * - Pull out common wnext == 0 case for speed 49 * - Make op and len in inflate_fast() unsigne 50 * - Add FAR to lcode and dcode declarations i 51 * - Simplified bad distance check in inflate_ 52 * - Added inflateBackInit(), inflateBack(), a 53 * source file infback.c to provide a call-b 54 * programs like gzip and unzip -- uses wind 55 * window copying 56 * 57 * 1.2.beta5 1 Jan 2003 58 * - Improved inflateBack() interface to allow 59 * input in strm. 60 * - Fixed stored blocks bug in inflateBack() 61 * 62 * 1.2.beta6 4 Jan 2003 63 * - Added comments in inffast.c on effectiven 64 * - Typecasting all around to reduce compiler 65 * - Changed loops from while (1) or do {} whi 66 * make compilers happy 67 * - Changed type of window in inflateBackInit 68 * 69 * 1.2.beta7 27 Jan 2003 70 * - Changed many types to unsigned or unsigne 71 * - Added inflateCopy() function 72 * 73 * 1.2.0 9 Mar 2003 74 * - Changed inflateBack() interface to provid 75 * for the in() and out() functions 76 * - Changed inflateBack() argument and in_fun 77 * and buffer address return values for the 78 * - Check next_in and next_out for Z_NULL on 79 * 80 * The history for versions after 1.2.0 are in 81 */ 82 83 #include "zutil.h" 84 #include "inftrees.h" 85 #include "inflate.h" 86 #include "inffast.h" 87 88 #ifdef MAKEFIXED 89 # ifndef BUILDFIXED 90 # define BUILDFIXED 91 # endif 92 #endif 93 94 /* function prototypes */ 95 local int inflateStateCheck OF((z_streamp strm 96 local void fixedtables OF((struct inflate_stat 97 local int updatewindow OF((z_streamp strm, con 98 unsigned copy)); 99 #ifdef BUILDFIXED 100 void makefixed OF((void)); 101 #endif 102 local unsigned syncsearch OF((unsigned FAR *ha 103 unsigned len)); 104 105 local int inflateStateCheck(strm) 106 z_streamp strm; 107 { 108 struct inflate_state FAR *state; 109 if (strm == Z_NULL || 110 strm->zalloc == (alloc_func)0 || strm- 111 return 1; 112 state = (struct inflate_state FAR *)strm-> 113 if (state == Z_NULL || state->strm != strm 114 state->mode < HEAD || state->mode > SY 115 return 1; 116 return 0; 117 } 118 119 int ZEXPORT inflateResetKeep(strm) 120 z_streamp strm; 121 { 122 struct inflate_state FAR *state; 123 124 if (inflateStateCheck(strm)) return Z_STRE 125 state = (struct inflate_state FAR *)strm-> 126 strm->total_in = strm->total_out = state-> 127 strm->msg = Z_NULL; 128 if (state->wrap) /* to support ill- 129 strm->adler = state->wrap & 1; 130 state->mode = HEAD; 131 state->last = 0; 132 state->havedict = 0; 133 state->flags = -1; 134 state->dmax = 32768U; 135 state->head = Z_NULL; 136 state->hold = 0; 137 state->bits = 0; 138 state->lencode = state->distcode = state-> 139 state->sane = 1; 140 state->back = -1; 141 Tracev((stderr, "inflate: reset\n")); 142 return Z_OK; 143 } 144 145 int ZEXPORT inflateReset(strm) 146 z_streamp strm; 147 { 148 struct inflate_state FAR *state; 149 150 if (inflateStateCheck(strm)) return Z_STRE 151 state = (struct inflate_state FAR *)strm-> 152 state->wsize = 0; 153 state->whave = 0; 154 state->wnext = 0; 155 return inflateResetKeep(strm); 156 } 157 158 int ZEXPORT inflateReset2(strm, windowBits) 159 z_streamp strm; 160 int windowBits; 161 { 162 int wrap; 163 struct inflate_state FAR *state; 164 165 /* get the state */ 166 if (inflateStateCheck(strm)) return Z_STRE 167 state = (struct inflate_state FAR *)strm-> 168 169 /* extract wrap request from windowBits pa 170 if (windowBits < 0) { 171 if (windowBits < -15) 172 return Z_STREAM_ERROR; 173 wrap = 0; 174 windowBits = -windowBits; 175 } 176 else { 177 wrap = (windowBits >> 4) + 5; 178 #ifdef GUNZIP 179 if (windowBits < 48) 180 windowBits &= 15; 181 #endif 182 } 183 184 /* set number of window bits, free window 185 if (windowBits && (windowBits < 8 || windo 186 return Z_STREAM_ERROR; 187 if (state->window != Z_NULL && state->wbit 188 ZFREE(strm, state->window); 189 state->window = Z_NULL; 190 } 191 192 /* update state and reset the rest of it * 193 state->wrap = wrap; 194 state->wbits = (unsigned)windowBits; 195 return inflateReset(strm); 196 } 197 198 int ZEXPORT inflateInit2_(strm, windowBits, ve 199 z_streamp strm; 200 int windowBits; 201 const char *version; 202 int stream_size; 203 { 204 int ret; 205 struct inflate_state FAR *state; 206 207 if (version == Z_NULL || version[0] != ZLI 208 stream_size != (int)(sizeof(z_stream)) 209 return Z_VERSION_ERROR; 210 if (strm == Z_NULL) return Z_STREAM_ERROR; 211 strm->msg = Z_NULL; /* in 212 if (strm->zalloc == (alloc_func)0) { 213 #ifdef Z_SOLO 214 return Z_STREAM_ERROR; 215 #else 216 strm->zalloc = zcalloc; 217 strm->opaque = (voidpf)0; 218 #endif 219 } 220 if (strm->zfree == (free_func)0) 221 #ifdef Z_SOLO 222 return Z_STREAM_ERROR; 223 #else 224 strm->zfree = zcfree; 225 #endif 226 state = (struct inflate_state FAR *) 227 ZALLOC(strm, 1, sizeof(struct infl 228 if (state == Z_NULL) return Z_MEM_ERROR; 229 Tracev((stderr, "inflate: allocated\n")); 230 strm->state = (struct internal_state FAR * 231 state->strm = strm; 232 state->window = Z_NULL; 233 state->mode = HEAD; /* to pass state t 234 ret = inflateReset2(strm, windowBits); 235 if (ret != Z_OK) { 236 ZFREE(strm, state); 237 strm->state = Z_NULL; 238 } 239 return ret; 240 } 241 242 int ZEXPORT inflateInit_(strm, version, stream 243 z_streamp strm; 244 const char *version; 245 int stream_size; 246 { 247 return inflateInit2_(strm, DEF_WBITS, vers 248 } 249 250 int ZEXPORT inflatePrime(strm, bits, value) 251 z_streamp strm; 252 int bits; 253 int value; 254 { 255 struct inflate_state FAR *state; 256 257 if (inflateStateCheck(strm)) return Z_STRE 258 state = (struct inflate_state FAR *)strm-> 259 if (bits < 0) { 260 state->hold = 0; 261 state->bits = 0; 262 return Z_OK; 263 } 264 if (bits > 16 || state->bits + (uInt)bits 265 value &= (1L << bits) - 1; 266 state->hold += (unsigned)value << state->b 267 state->bits += (uInt)bits; 268 return Z_OK; 269 } 270 271 /* 272 Return state with length and distance decod 273 fixed code decoding. Normally this returns 274 If BUILDFIXED is defined, then instead this 275 first time it's called, and returns those t 276 thereafter. This reduces the size of the c 277 exchange for a little execution time. Howe 278 used for threaded applications, since the r 279 may not be thread-safe. 280 */ 281 local void fixedtables(state) 282 struct inflate_state FAR *state; 283 { 284 #ifdef BUILDFIXED 285 static int virgin = 1; 286 static code *lenfix, *distfix; 287 static code fixed[544]; 288 289 /* build fixed huffman tables if first cal 290 if (virgin) { 291 unsigned sym, bits; 292 static code *next; 293 294 /* literal/length table */ 295 sym = 0; 296 while (sym < 144) state->lens[sym++] = 297 while (sym < 256) state->lens[sym++] = 298 while (sym < 280) state->lens[sym++] = 299 while (sym < 288) state->lens[sym++] = 300 next = fixed; 301 lenfix = next; 302 bits = 9; 303 inflate_table(LENS, state->lens, 288, 304 305 /* distance table */ 306 sym = 0; 307 while (sym < 32) state->lens[sym++] = 308 distfix = next; 309 bits = 5; 310 inflate_table(DISTS, state->lens, 32, 311 312 /* do this just once */ 313 virgin = 0; 314 } 315 #else /* !BUILDFIXED */ 316 # include "inffixed.h" 317 #endif /* BUILDFIXED */ 318 state->lencode = lenfix; 319 state->lenbits = 9; 320 state->distcode = distfix; 321 state->distbits = 5; 322 } 323 324 #ifdef MAKEFIXED 325 #include <stdio.h> 326 327 /* 328 Write out the inffixed.h that is #include'd 329 defines BUILDFIXED, so the tables are built 330 those tables to stdout, which would be pipe 331 can simply call makefixed to do this: 332 333 void makefixed(void); 334 335 int main(void) 336 { 337 makefixed(); 338 return 0; 339 } 340 341 Then that can be linked with zlib built wit 342 343 a.out > inffixed.h 344 */ 345 void makefixed() 346 { 347 unsigned low, size; 348 struct inflate_state state; 349 350 fixedtables(&state); 351 puts(" /* inffixed.h -- table for decod 352 puts(" * Generated automatically by ma 353 puts(" */"); 354 puts(""); 355 puts(" /* WARNING: this file should *no 356 puts(" It is part of the implementat 357 puts(" subject to change. Applicatio 358 puts(" */"); 359 puts(""); 360 size = 1U << 9; 361 printf(" static const code lenfix[%u] = 362 low = 0; 363 for (;;) { 364 if ((low % 7) == 0) printf("\n 365 printf("{%u,%u,%d}", (low & 127) == 99 366 state.lencode[low].bits, state. 367 if (++low == size) break; 368 putchar(','); 369 } 370 puts("\n };"); 371 size = 1U << 5; 372 printf("\n static const code distfix[%u 373 low = 0; 374 for (;;) { 375 if ((low % 6) == 0) printf("\n 376 printf("{%u,%u,%d}", state.distcode[lo 377 state.distcode[low].val); 378 if (++low == size) break; 379 putchar(','); 380 } 381 puts("\n };"); 382 } 383 #endif /* MAKEFIXED */ 384 385 /* 386 Update the window with the last wsize (norm 387 returning. If window does not exist yet, c 388 when a window is already in use, or when ou 389 inflate call, but the end of the deflate st 390 It is also called to create a window for di 391 is loaded. 392 393 Providing output buffers larger than 32K to 394 advantage, since only the last 32K of outpu 395 upon return from inflate(), and since all d 396 output will fall in the output data, making 397 The advantage may be dependent on the size 398 */ 399 local int updatewindow(strm, end, copy) 400 z_streamp strm; 401 const Bytef *end; 402 unsigned copy; 403 { 404 struct inflate_state FAR *state; 405 unsigned dist; 406 407 state = (struct inflate_state FAR *)strm-> 408 409 /* if it hasn't been done already, allocat 410 if (state->window == Z_NULL) { 411 state->window = (unsigned char FAR *) 412 ZALLOC(strm, 1U << sta 413 sizeof(unsigned 414 if (state->window == Z_NULL) return 1; 415 } 416 417 /* if window not in use yet, initialize */ 418 if (state->wsize == 0) { 419 state->wsize = 1U << state->wbits; 420 state->wnext = 0; 421 state->whave = 0; 422 } 423 424 /* copy state->wsize or less output bytes 425 if (copy >= state->wsize) { 426 zmemcpy(state->window, end - state->ws 427 state->wnext = 0; 428 state->whave = state->wsize; 429 } 430 else { 431 dist = state->wsize - state->wnext; 432 if (dist > copy) dist = copy; 433 zmemcpy(state->window + state->wnext, 434 copy -= dist; 435 if (copy) { 436 zmemcpy(state->window, end - copy, 437 state->wnext = copy; 438 state->whave = state->wsize; 439 } 440 else { 441 state->wnext += dist; 442 if (state->wnext == state->wsize) 443 if (state->whave < state->wsize) s 444 } 445 } 446 return 0; 447 } 448 449 /* Macros for inflate(): */ 450 451 /* check function to use adler32() for zlib or 452 #ifdef GUNZIP 453 # define UPDATE_CHECK(check, buf, len) \ 454 (state->flags ? crc32(check, buf, len) : a 455 #else 456 # define UPDATE_CHECK(check, buf, len) adler3 457 #endif 458 459 /* check macros for header crc */ 460 #ifdef GUNZIP 461 # define CRC2(check, word) \ 462 do { \ 463 hbuf[0] = (unsigned char)(word); \ 464 hbuf[1] = (unsigned char)((word) >> 8) 465 check = crc32(check, hbuf, 2); \ 466 } while (0) 467 468 # define CRC4(check, word) \ 469 do { \ 470 hbuf[0] = (unsigned char)(word); \ 471 hbuf[1] = (unsigned char)((word) >> 8) 472 hbuf[2] = (unsigned char)((word) >> 16 473 hbuf[3] = (unsigned char)((word) >> 24 474 check = crc32(check, hbuf, 4); \ 475 } while (0) 476 #endif 477 478 /* Load registers with state in inflate() for 479 #define LOAD() \ 480 do { \ 481 put = strm->next_out; \ 482 left = strm->avail_out; \ 483 next = strm->next_in; \ 484 have = strm->avail_in; \ 485 hold = state->hold; \ 486 bits = state->bits; \ 487 } while (0) 488 489 /* Restore state from registers in inflate() * 490 #define RESTORE() \ 491 do { \ 492 strm->next_out = put; \ 493 strm->avail_out = left; \ 494 strm->next_in = next; \ 495 strm->avail_in = have; \ 496 state->hold = hold; \ 497 state->bits = bits; \ 498 } while (0) 499 500 /* Clear the input bit accumulator */ 501 #define INITBITS() \ 502 do { \ 503 hold = 0; \ 504 bits = 0; \ 505 } while (0) 506 507 /* Get a byte of input into the bit accumulato 508 if there is no input available. */ 509 #define PULLBYTE() \ 510 do { \ 511 if (have == 0) goto inf_leave; \ 512 have--; \ 513 hold += (unsigned long)(*next++) << bi 514 bits += 8; \ 515 } while (0) 516 517 /* Assure that there are at least n bits in th 518 not enough available input to do that, then 519 #define NEEDBITS(n) \ 520 do { \ 521 while (bits < (unsigned)(n)) \ 522 PULLBYTE(); \ 523 } while (0) 524 525 /* Return the low n bits of the bit accumulato 526 #define BITS(n) \ 527 ((unsigned)hold & ((1U << (n)) - 1)) 528 529 /* Remove n bits from the bit accumulator */ 530 #define DROPBITS(n) \ 531 do { \ 532 hold >>= (n); \ 533 bits -= (unsigned)(n); \ 534 } while (0) 535 536 /* Remove zero to seven bits as needed to go t 537 #define BYTEBITS() \ 538 do { \ 539 hold >>= bits & 7; \ 540 bits -= bits & 7; \ 541 } while (0) 542 543 /* 544 inflate() uses a state machine to process a 545 much output data as possible before returni 546 structured roughly as follows: 547 548 for (;;) switch (state) { 549 ... 550 case STATEn: 551 if (not enough input data or output sp 552 return; 553 ... make progress ... 554 state = STATEm; 555 break; 556 ... 557 } 558 559 so when inflate() is called again, the same 560 if the appropriate resources are provided, 561 next state. The NEEDBITS() macro is usuall 562 whether it can proceed or should return. N 563 the requested bits are not available. The 564 is: 565 566 NEEDBITS(n); 567 ... do something with BITS(n) ... 568 DROPBITS(n); 569 570 where NEEDBITS(n) either returns from infla 571 input left to load n bits into the accumula 572 gives the low n bits in the accumulator. W 573 the low n bits off the accumulator. INITBI 574 and sets the number of available bits to ze 575 enough bits to put the accumulator on a byt 576 and a NEEDBITS(8), then BITS(8) would retur 577 578 NEEDBITS(n) uses PULLBYTE() to get an avail 579 if there is no input available. The decodi 580 PULLBYTE() directly in order to pull just e 581 code, and no more. 582 583 Some states loop until they get enough inpu 584 state information is maintained to continue 585 if NEEDBITS() returns in the loop. For exa 586 would all have to actually be part of the s 587 returns: 588 589 case STATEw: 590 while (want < need) { 591 NEEDBITS(n); 592 keep[want++] = BITS(n); 593 DROPBITS(n); 594 } 595 state = STATEx; 596 case STATEx: 597 598 As shown above, if the next state is also t 599 is omitted. 600 601 A state may also return if there is not eno 602 complete that state. Those states are copy 603 literal byte, and copying a matching string 604 605 When returning, a "goto inf_leave" is used 606 update the check value, and determine wheth 607 during that inflate() call in order to retu 608 Progress is defined as a change in either s 609 When there is a window, goto inf_leave will 610 output written. If a goto inf_leave occurs 611 and there is no window currently, goto inf_ 612 output to the window for the next call of i 613 614 In this implementation, the flush parameter 615 return code (per zlib.h). inflate() always 616 strm->next_out, given the space available a 617 documented in zlib.h of Z_SYNC_FLUSH. Furt 618 the allocation of and copying into a slidin 619 provides the effect documented in zlib.h fo 620 stream available. So the only thing the fl 621 when flush is set to Z_FINISH, inflate() ca 622 will return Z_BUF_ERROR if it has not reach 623 */ 624 625 int ZEXPORT inflate(strm, flush) 626 z_streamp strm; 627 int flush; 628 { 629 struct inflate_state FAR *state; 630 z_const unsigned char FAR *next; /* nex 631 unsigned char FAR *put; /* next output 632 unsigned have, left; /* available i 633 unsigned long hold; /* bit buffer 634 unsigned bits; /* bits in bit 635 unsigned in, out; /* save starti 636 unsigned copy; /* number of s 637 unsigned char FAR *from; /* where to co 638 code here; /* current dec 639 code last; /* parent tabl 640 unsigned len; /* length to c 641 int ret; /* return code 642 #ifdef GUNZIP 643 unsigned char hbuf[4]; /* buffer for 644 #endif 645 static const unsigned short order[19] = /* 646 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 647 648 if (inflateStateCheck(strm) || strm->next_ 649 (strm->next_in == Z_NULL && strm->avai 650 return Z_STREAM_ERROR; 651 652 state = (struct inflate_state FAR *)strm-> 653 if (state->mode == TYPE) state->mode = TYP 654 LOAD(); 655 in = have; 656 out = left; 657 ret = Z_OK; 658 for (;;) 659 switch (state->mode) { 660 case HEAD: 661 if (state->wrap == 0) { 662 state->mode = TYPEDO; 663 break; 664 } 665 NEEDBITS(16); 666 #ifdef GUNZIP 667 if ((state->wrap & 2) && hold == 0 668 if (state->wbits == 0) 669 state->wbits = 15; 670 state->check = crc32(0L, Z_NUL 671 CRC2(state->check, hold); 672 INITBITS(); 673 state->mode = FLAGS; 674 break; 675 } 676 if (state->head != Z_NULL) 677 state->head->done = -1; 678 if (!(state->wrap & 1) || /* che 679 #else 680 if ( 681 #endif 682 ((BITS(8) << 8) + (hold >> 8)) 683 strm->msg = (char *)"incorrect 684 state->mode = BAD; 685 break; 686 } 687 if (BITS(4) != Z_DEFLATED) { 688 strm->msg = (char *)"unknown c 689 state->mode = BAD; 690 break; 691 } 692 DROPBITS(4); 693 len = BITS(4) + 8; 694 if (state->wbits == 0) 695 state->wbits = len; 696 if (len > 15 || len > state->wbits 697 strm->msg = (char *)"invalid w 698 state->mode = BAD; 699 break; 700 } 701 state->dmax = 1U << len; 702 state->flags = 0; /* 703 Tracev((stderr, "inflate: zlib h 704 strm->adler = state->check = adler 705 state->mode = hold & 0x200 ? DICTI 706 INITBITS(); 707 break; 708 #ifdef GUNZIP 709 case FLAGS: 710 NEEDBITS(16); 711 state->flags = (int)(hold); 712 if ((state->flags & 0xff) != Z_DEF 713 strm->msg = (char *)"unknown c 714 state->mode = BAD; 715 break; 716 } 717 if (state->flags & 0xe000) { 718 strm->msg = (char *)"unknown h 719 state->mode = BAD; 720 break; 721 } 722 if (state->head != Z_NULL) 723 state->head->text = (int)((hol 724 if ((state->flags & 0x0200) && (st 725 CRC2(state->check, hold); 726 INITBITS(); 727 state->mode = TIME; 728 /* fallthrough */ 729 case TIME: 730 NEEDBITS(32); 731 if (state->head != Z_NULL) 732 state->head->time = hold; 733 if ((state->flags & 0x0200) && (st 734 CRC4(state->check, hold); 735 INITBITS(); 736 state->mode = OS; 737 /* fallthrough */ 738 case OS: 739 NEEDBITS(16); 740 if (state->head != Z_NULL) { 741 state->head->xflags = (int)(ho 742 state->head->os = (int)(hold > 743 } 744 if ((state->flags & 0x0200) && (st 745 CRC2(state->check, hold); 746 INITBITS(); 747 state->mode = EXLEN; 748 /* fallthrough */ 749 case EXLEN: 750 if (state->flags & 0x0400) { 751 NEEDBITS(16); 752 state->length = (unsigned)(hol 753 if (state->head != Z_NULL) 754 state->head->extra_len = ( 755 if ((state->flags & 0x0200) && 756 CRC2(state->check, hold); 757 INITBITS(); 758 } 759 else if (state->head != Z_NULL) 760 state->head->extra = Z_NULL; 761 state->mode = EXTRA; 762 /* fallthrough */ 763 case EXTRA: 764 if (state->flags & 0x0400) { 765 copy = state->length; 766 if (copy > have) copy = have; 767 if (copy) { 768 if (state->head != Z_NULL 769 state->head->extra != 770 (len = state->head->ex 771 state->head->extra 772 zmemcpy(state->head->e 773 len + copy > s 774 state->head->e 775 } 776 if ((state->flags & 0x0200 777 state->check = crc32(s 778 have -= copy; 779 next += copy; 780 state->length -= copy; 781 } 782 if (state->length) goto inf_le 783 } 784 state->length = 0; 785 state->mode = NAME; 786 /* fallthrough */ 787 case NAME: 788 if (state->flags & 0x0800) { 789 if (have == 0) goto inf_leave; 790 copy = 0; 791 do { 792 len = (unsigned)(next[copy 793 if (state->head != Z_NULL 794 state->head->name 795 state->length < st 796 state->head->name[stat 797 } while (len && copy < have); 798 if ((state->flags & 0x0200) && 799 state->check = crc32(state 800 have -= copy; 801 next += copy; 802 if (len) goto inf_leave; 803 } 804 else if (state->head != Z_NULL) 805 state->head->name = Z_NULL; 806 state->length = 0; 807 state->mode = COMMENT; 808 /* fallthrough */ 809 case COMMENT: 810 if (state->flags & 0x1000) { 811 if (have == 0) goto inf_leave; 812 copy = 0; 813 do { 814 len = (unsigned)(next[copy 815 if (state->head != Z_NULL 816 state->head->comme 817 state->length < st 818 state->head->comment[s 819 } while (len && copy < have); 820 if ((state->flags & 0x0200) && 821 state->check = crc32(state 822 have -= copy; 823 next += copy; 824 if (len) goto inf_leave; 825 } 826 else if (state->head != Z_NULL) 827 state->head->comment = Z_NULL; 828 state->mode = HCRC; 829 /* fallthrough */ 830 case HCRC: 831 if (state->flags & 0x0200) { 832 NEEDBITS(16); 833 if ((state->wrap & 4) && hold 834 strm->msg = (char *)"heade 835 state->mode = BAD; 836 break; 837 } 838 INITBITS(); 839 } 840 if (state->head != Z_NULL) { 841 state->head->hcrc = (int)((sta 842 state->head->done = 1; 843 } 844 strm->adler = state->check = crc32 845 state->mode = TYPE; 846 break; 847 #endif 848 case DICTID: 849 NEEDBITS(32); 850 strm->adler = state->check = ZSWAP 851 INITBITS(); 852 state->mode = DICT; 853 /* fallthrough */ 854 case DICT: 855 if (state->havedict == 0) { 856 RESTORE(); 857 return Z_NEED_DICT; 858 } 859 strm->adler = state->check = adler 860 state->mode = TYPE; 861 /* fallthrough */ 862 case TYPE: 863 if (flush == Z_BLOCK || flush == Z 864 /* fallthrough */ 865 case TYPEDO: 866 if (state->last) { 867 BYTEBITS(); 868 state->mode = CHECK; 869 break; 870 } 871 NEEDBITS(3); 872 state->last = BITS(1); 873 DROPBITS(1); 874 switch (BITS(2)) { 875 case 0: 876 Tracev((stderr, "inflate: 877 state->last ? " (last) 878 state->mode = STORED; 879 break; 880 case 1: 881 fixedtables(state); 882 Tracev((stderr, "inflate: 883 state->last ? " (last) 884 state->mode = LEN_; 885 if (flush == Z_TREES) { 886 DROPBITS(2); 887 goto inf_leave; 888 } 889 break; 890 case 2: 891 Tracev((stderr, "inflate: 892 state->last ? " (last) 893 state->mode = TABLE; 894 break; 895 case 3: 896 strm->msg = (char *)"invalid b 897 state->mode = BAD; 898 } 899 DROPBITS(2); 900 break; 901 case STORED: 902 BYTEBITS(); 903 NEEDBITS(32); 904 if ((hold & 0xffff) != ((hold >> 1 905 strm->msg = (char *)"invalid s 906 state->mode = BAD; 907 break; 908 } 909 state->length = (unsigned)hold & 0 910 Tracev((stderr, "inflate: st 911 state->length)); 912 INITBITS(); 913 state->mode = COPY_; 914 if (flush == Z_TREES) goto inf_lea 915 /* fallthrough */ 916 case COPY_: 917 state->mode = COPY; 918 /* fallthrough */ 919 case COPY: 920 copy = state->length; 921 if (copy) { 922 if (copy > have) copy = have; 923 if (copy > left) copy = left; 924 if (copy == 0) goto inf_leave; 925 zmemcpy(put, next, copy); 926 have -= copy; 927 next += copy; 928 left -= copy; 929 put += copy; 930 state->length -= copy; 931 break; 932 } 933 Tracev((stderr, "inflate: st 934 state->mode = TYPE; 935 break; 936 case TABLE: 937 NEEDBITS(14); 938 state->nlen = BITS(5) + 257; 939 DROPBITS(5); 940 state->ndist = BITS(5) + 1; 941 DROPBITS(5); 942 state->ncode = BITS(4) + 4; 943 DROPBITS(4); 944 #ifndef PKZIP_BUG_WORKAROUND 945 if (state->nlen > 286 || state->nd 946 strm->msg = (char *)"too many 947 state->mode = BAD; 948 break; 949 } 950 #endif 951 Tracev((stderr, "inflate: ta 952 state->have = 0; 953 state->mode = LENLENS; 954 /* fallthrough */ 955 case LENLENS: 956 while (state->have < state->ncode) 957 NEEDBITS(3); 958 state->lens[order[state->have+ 959 DROPBITS(3); 960 } 961 while (state->have < 19) 962 state->lens[order[state->have+ 963 state->next = state->codes; 964 state->lencode = (const code FAR * 965 state->lenbits = 7; 966 ret = inflate_table(CODES, state-> 967 &(state->lenbi 968 if (ret) { 969 strm->msg = (char *)"invalid c 970 state->mode = BAD; 971 break; 972 } 973 Tracev((stderr, "inflate: co 974 state->have = 0; 975 state->mode = CODELENS; 976 /* fallthrough */ 977 case CODELENS: 978 while (state->have < state->nlen + 979 for (;;) { 980 here = state->lencode[BITS 981 if ((unsigned)(here.bits) 982 PULLBYTE(); 983 } 984 if (here.val < 16) { 985 DROPBITS(here.bits); 986 state->lens[state->have++] 987 } 988 else { 989 if (here.val == 16) { 990 NEEDBITS(here.bits + 2 991 DROPBITS(here.bits); 992 if (state->have == 0) 993 strm->msg = (char 994 state->mode = BAD; 995 break; 996 } 997 len = state->lens[stat 998 copy = 3 + BITS(2); 999 DROPBITS(2); 1000 } 1001 else if (here.val == 17) 1002 NEEDBITS(here.bits + 1003 DROPBITS(here.bits); 1004 len = 0; 1005 copy = 3 + BITS(3); 1006 DROPBITS(3); 1007 } 1008 else { 1009 NEEDBITS(here.bits + 1010 DROPBITS(here.bits); 1011 len = 0; 1012 copy = 11 + BITS(7); 1013 DROPBITS(7); 1014 } 1015 if (state->have + copy > 1016 strm->msg = (char *)" 1017 state->mode = BAD; 1018 break; 1019 } 1020 while (copy--) 1021 state->lens[state->ha 1022 } 1023 } 1024 1025 /* handle error breaks in while * 1026 if (state->mode == BAD) break; 1027 1028 /* check for end-of-block code (b 1029 if (state->lens[256] == 0) { 1030 strm->msg = (char *)"invalid 1031 state->mode = BAD; 1032 break; 1033 } 1034 1035 /* build code tables -- note: do 1036 values here (9 and 6) without 1037 concerning the ENOUGH constant 1038 state->next = state->codes; 1039 state->lencode = (const code FAR 1040 state->lenbits = 9; 1041 ret = inflate_table(LENS, state-> 1042 &(state->lenb 1043 if (ret) { 1044 strm->msg = (char *)"invalid 1045 state->mode = BAD; 1046 break; 1047 } 1048 state->distcode = (const code FAR 1049 state->distbits = 6; 1050 ret = inflate_table(DISTS, state- 1051 &(state->next), & 1052 if (ret) { 1053 strm->msg = (char *)"invalid 1054 state->mode = BAD; 1055 break; 1056 } 1057 Tracev((stderr, "inflate: c 1058 state->mode = LEN_; 1059 if (flush == Z_TREES) goto inf_le 1060 /* fallthrough */ 1061 case LEN_: 1062 state->mode = LEN; 1063 /* fallthrough */ 1064 case LEN: 1065 if (have >= 6 && left >= 258) { 1066 RESTORE(); 1067 inflate_fast(strm, out); 1068 LOAD(); 1069 if (state->mode == TYPE) 1070 state->back = -1; 1071 break; 1072 } 1073 state->back = 0; 1074 for (;;) { 1075 here = state->lencode[BITS(st 1076 if ((unsigned)(here.bits) <= 1077 PULLBYTE(); 1078 } 1079 if (here.op && (here.op & 0xf0) = 1080 last = here; 1081 for (;;) { 1082 here = state->lencode[las 1083 (BITS(last.bits + 1084 if ((unsigned)(last.bits 1085 PULLBYTE(); 1086 } 1087 DROPBITS(last.bits); 1088 state->back += last.bits; 1089 } 1090 DROPBITS(here.bits); 1091 state->back += here.bits; 1092 state->length = (unsigned)here.va 1093 if ((int)(here.op) == 0) { 1094 Tracevv((stderr, here.val >= 1095 "inflate: lit 1096 "inflate: lit 1097 state->mode = LIT; 1098 break; 1099 } 1100 if (here.op & 32) { 1101 Tracevv((stderr, "inflate: 1102 state->back = -1; 1103 state->mode = TYPE; 1104 break; 1105 } 1106 if (here.op & 64) { 1107 strm->msg = (char *)"invalid 1108 state->mode = BAD; 1109 break; 1110 } 1111 state->extra = (unsigned)(here.op 1112 state->mode = LENEXT; 1113 /* fallthrough */ 1114 case LENEXT: 1115 if (state->extra) { 1116 NEEDBITS(state->extra); 1117 state->length += BITS(state-> 1118 DROPBITS(state->extra); 1119 state->back += state->extra; 1120 } 1121 Tracevv((stderr, "inflate: 1122 state->was = state->length; 1123 state->mode = DIST; 1124 /* fallthrough */ 1125 case DIST: 1126 for (;;) { 1127 here = state->distcode[BITS(s 1128 if ((unsigned)(here.bits) <= 1129 PULLBYTE(); 1130 } 1131 if ((here.op & 0xf0) == 0) { 1132 last = here; 1133 for (;;) { 1134 here = state->distcode[la 1135 (BITS(last.bits + 1136 if ((unsigned)(last.bits 1137 PULLBYTE(); 1138 } 1139 DROPBITS(last.bits); 1140 state->back += last.bits; 1141 } 1142 DROPBITS(here.bits); 1143 state->back += here.bits; 1144 if (here.op & 64) { 1145 strm->msg = (char *)"invalid 1146 state->mode = BAD; 1147 break; 1148 } 1149 state->offset = (unsigned)here.va 1150 state->extra = (unsigned)(here.op 1151 state->mode = DISTEXT; 1152 /* fallthrough */ 1153 case DISTEXT: 1154 if (state->extra) { 1155 NEEDBITS(state->extra); 1156 state->offset += BITS(state-> 1157 DROPBITS(state->extra); 1158 state->back += state->extra; 1159 } 1160 #ifdef INFLATE_STRICT 1161 if (state->offset > state->dmax) 1162 strm->msg = (char *)"invalid 1163 state->mode = BAD; 1164 break; 1165 } 1166 #endif 1167 Tracevv((stderr, "inflate: 1168 state->mode = MATCH; 1169 /* fallthrough */ 1170 case MATCH: 1171 if (left == 0) goto inf_leave; 1172 copy = out - left; 1173 if (state->offset > copy) { 1174 copy = state->offset - copy; 1175 if (copy > state->whave) { 1176 if (state->sane) { 1177 strm->msg = (char *)" 1178 state->mode = BAD; 1179 break; 1180 } 1181 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ 1182 Trace((stderr, "inflate.c 1183 copy -= state->whave; 1184 if (copy > state->length) 1185 if (copy > left) copy = l 1186 left -= copy; 1187 state->length -= copy; 1188 do { 1189 *put++ = 0; 1190 } while (--copy); 1191 if (state->length == 0) s 1192 break; 1193 #endif 1194 } 1195 if (copy > state->wnext) { 1196 copy -= state->wnext; 1197 from = state->window + (s 1198 } 1199 else 1200 from = state->window + (s 1201 if (copy > state->length) cop 1202 } 1203 else { 1204 from = put - state->offset; 1205 copy = state->length; 1206 } 1207 if (copy > left) copy = left; 1208 left -= copy; 1209 state->length -= copy; 1210 do { 1211 *put++ = *from++; 1212 } while (--copy); 1213 if (state->length == 0) state->mo 1214 break; 1215 case LIT: 1216 if (left == 0) goto inf_leave; 1217 *put++ = (unsigned char)(state->l 1218 left--; 1219 state->mode = LEN; 1220 break; 1221 case CHECK: 1222 if (state->wrap) { 1223 NEEDBITS(32); 1224 out -= left; 1225 strm->total_out += out; 1226 state->total += out; 1227 if ((state->wrap & 4) && out) 1228 strm->adler = state->chec 1229 UPDATE_CHECK(state->c 1230 out = left; 1231 if ((state->wrap & 4) && ( 1232 #ifdef GUNZIP 1233 state->flags ? hold : 1234 #endif 1235 ZSWAP32(hold)) != state- 1236 strm->msg = (char *)"inco 1237 state->mode = BAD; 1238 break; 1239 } 1240 INITBITS(); 1241 Tracev((stderr, "inflate: c 1242 } 1243 #ifdef GUNZIP 1244 state->mode = LENGTH; 1245 /* fallthrough */ 1246 case LENGTH: 1247 if (state->wrap && state->flags) 1248 NEEDBITS(32); 1249 if ((state->wrap & 4) && hold 1250 strm->msg = (char *)"inco 1251 state->mode = BAD; 1252 break; 1253 } 1254 INITBITS(); 1255 Tracev((stderr, "inflate: l 1256 } 1257 #endif 1258 state->mode = DONE; 1259 /* fallthrough */ 1260 case DONE: 1261 ret = Z_STREAM_END; 1262 goto inf_leave; 1263 case BAD: 1264 ret = Z_DATA_ERROR; 1265 goto inf_leave; 1266 case MEM: 1267 return Z_MEM_ERROR; 1268 case SYNC: 1269 /* fallthrough */ 1270 default: 1271 return Z_STREAM_ERROR; 1272 } 1273 1274 /* 1275 Return from inflate(), updating the to 1276 If there was no progress during the in 1277 error. Call updatewindow() to create 1278 Note: a memory error from inflate() is 1279 */ 1280 inf_leave: 1281 RESTORE(); 1282 if (state->wsize || (out != strm->avail_o 1283 (state->mode < CHECK || flush != 1284 if (updatewindow(strm, strm->next_out 1285 state->mode = MEM; 1286 return Z_MEM_ERROR; 1287 } 1288 in -= strm->avail_in; 1289 out -= strm->avail_out; 1290 strm->total_in += in; 1291 strm->total_out += out; 1292 state->total += out; 1293 if ((state->wrap & 4) && out) 1294 strm->adler = state->check = 1295 UPDATE_CHECK(state->check, strm-> 1296 strm->data_type = (int)state->bits + (sta 1297 (state->mode == TYPE ? 1298 (state->mode == LEN_ || 1299 if (((in == 0 && out == 0) || flush == Z_ 1300 ret = Z_BUF_ERROR; 1301 return ret; 1302 } 1303 1304 int ZEXPORT inflateEnd(strm) 1305 z_streamp strm; 1306 { 1307 struct inflate_state FAR *state; 1308 if (inflateStateCheck(strm)) 1309 return Z_STREAM_ERROR; 1310 state = (struct inflate_state FAR *)strm- 1311 if (state->window != Z_NULL) ZFREE(strm, 1312 ZFREE(strm, strm->state); 1313 strm->state = Z_NULL; 1314 Tracev((stderr, "inflate: end\n")); 1315 return Z_OK; 1316 } 1317 1318 int ZEXPORT inflateGetDictionary(strm, dictio 1319 z_streamp strm; 1320 Bytef *dictionary; 1321 uInt *dictLength; 1322 { 1323 struct inflate_state FAR *state; 1324 1325 /* check state */ 1326 if (inflateStateCheck(strm)) return Z_STR 1327 state = (struct inflate_state FAR *)strm- 1328 1329 /* copy dictionary */ 1330 if (state->whave && dictionary != Z_NULL) 1331 zmemcpy(dictionary, state->window + s 1332 state->whave - state->wnext); 1333 zmemcpy(dictionary + state->whave - s 1334 state->window, state->wnext); 1335 } 1336 if (dictLength != Z_NULL) 1337 *dictLength = state->whave; 1338 return Z_OK; 1339 } 1340 1341 int ZEXPORT inflateSetDictionary(strm, dictio 1342 z_streamp strm; 1343 const Bytef *dictionary; 1344 uInt dictLength; 1345 { 1346 struct inflate_state FAR *state; 1347 unsigned long dictid; 1348 int ret; 1349 1350 /* check state */ 1351 if (inflateStateCheck(strm)) return Z_STR 1352 state = (struct inflate_state FAR *)strm- 1353 if (state->wrap != 0 && state->mode != DI 1354 return Z_STREAM_ERROR; 1355 1356 /* check for correct dictionary identifie 1357 if (state->mode == DICT) { 1358 dictid = adler32(0L, Z_NULL, 0); 1359 dictid = adler32(dictid, dictionary, 1360 if (dictid != state->check) 1361 return Z_DATA_ERROR; 1362 } 1363 1364 /* copy dictionary to window using update 1365 existing dictionary if appropriate */ 1366 ret = updatewindow(strm, dictionary + dic 1367 if (ret) { 1368 state->mode = MEM; 1369 return Z_MEM_ERROR; 1370 } 1371 state->havedict = 1; 1372 Tracev((stderr, "inflate: dictionary se 1373 return Z_OK; 1374 } 1375 1376 int ZEXPORT inflateGetHeader(strm, head) 1377 z_streamp strm; 1378 gz_headerp head; 1379 { 1380 struct inflate_state FAR *state; 1381 1382 /* check state */ 1383 if (inflateStateCheck(strm)) return Z_STR 1384 state = (struct inflate_state FAR *)strm- 1385 if ((state->wrap & 2) == 0) return Z_STRE 1386 1387 /* save header structure */ 1388 state->head = head; 1389 head->done = 0; 1390 return Z_OK; 1391 } 1392 1393 /* 1394 Search buf[0..len-1] for the pattern: 0, 0 1395 or when out of input. When called, *have 1396 found in order so far, in 0..3. On return 1397 state. If on return *have equals four, th 1398 return value is how many bytes were read i 1399 pattern. If *have is less than four, then 1400 yet and the return value is len. In the l 1401 called again with more data and the *have 1402 zero for the first call. 1403 */ 1404 local unsigned syncsearch(have, buf, len) 1405 unsigned FAR *have; 1406 const unsigned char FAR *buf; 1407 unsigned len; 1408 { 1409 unsigned got; 1410 unsigned next; 1411 1412 got = *have; 1413 next = 0; 1414 while (next < len && got < 4) { 1415 if ((int)(buf[next]) == (got < 2 ? 0 1416 got++; 1417 else if (buf[next]) 1418 got = 0; 1419 else 1420 got = 4 - got; 1421 next++; 1422 } 1423 *have = got; 1424 return next; 1425 } 1426 1427 int ZEXPORT inflateSync(strm) 1428 z_streamp strm; 1429 { 1430 unsigned len; /* number of 1431 int flags; /* temporary 1432 unsigned long in, out; /* temporary 1433 unsigned char buf[4]; /* to restore 1434 struct inflate_state FAR *state; 1435 1436 /* check parameters */ 1437 if (inflateStateCheck(strm)) return Z_STR 1438 state = (struct inflate_state FAR *)strm- 1439 if (strm->avail_in == 0 && state->bits < 1440 1441 /* if first time, start search in bit buf 1442 if (state->mode != SYNC) { 1443 state->mode = SYNC; 1444 state->hold <<= state->bits & 7; 1445 state->bits -= state->bits & 7; 1446 len = 0; 1447 while (state->bits >= 8) { 1448 buf[len++] = (unsigned char)(stat 1449 state->hold >>= 8; 1450 state->bits -= 8; 1451 } 1452 state->have = 0; 1453 syncsearch(&(state->have), buf, len); 1454 } 1455 1456 /* search available input */ 1457 len = syncsearch(&(state->have), strm->ne 1458 strm->avail_in -= len; 1459 strm->next_in += len; 1460 strm->total_in += len; 1461 1462 /* return no joy or set up to restart inf 1463 if (state->have != 4) return Z_DATA_ERROR 1464 if (state->flags == -1) 1465 state->wrap = 0; /* if no header y 1466 else 1467 state->wrap &= ~4; /* no point in co 1468 flags = state->flags; 1469 in = strm->total_in; out = strm->total_o 1470 inflateReset(strm); 1471 strm->total_in = in; strm->total_out = o 1472 state->flags = flags; 1473 state->mode = TYPE; 1474 return Z_OK; 1475 } 1476 1477 /* 1478 Returns true if inflate is currently at th 1479 Z_SYNC_FLUSH or Z_FULL_FLUSH. This functio 1480 implementation to provide an additional sa 1481 Z_SYNC_FLUSH but removes the length bytes 1482 block. When decompressing, PPP checks that 1483 inflate is waiting for these length bytes. 1484 */ 1485 int ZEXPORT inflateSyncPoint(strm) 1486 z_streamp strm; 1487 { 1488 struct inflate_state FAR *state; 1489 1490 if (inflateStateCheck(strm)) return Z_STR 1491 state = (struct inflate_state FAR *)strm- 1492 return state->mode == STORED && state->bi 1493 } 1494 1495 int ZEXPORT inflateCopy(dest, source) 1496 z_streamp dest; 1497 z_streamp source; 1498 { 1499 struct inflate_state FAR *state; 1500 struct inflate_state FAR *copy; 1501 unsigned char FAR *window; 1502 unsigned wsize; 1503 1504 /* check input */ 1505 if (inflateStateCheck(source) || dest == 1506 return Z_STREAM_ERROR; 1507 state = (struct inflate_state FAR *)sourc 1508 1509 /* allocate space */ 1510 copy = (struct inflate_state FAR *) 1511 ZALLOC(source, 1, sizeof(struct in 1512 if (copy == Z_NULL) return Z_MEM_ERROR; 1513 window = Z_NULL; 1514 if (state->window != Z_NULL) { 1515 window = (unsigned char FAR *) 1516 ZALLOC(source, 1U << state-> 1517 if (window == Z_NULL) { 1518 ZFREE(source, copy); 1519 return Z_MEM_ERROR; 1520 } 1521 } 1522 1523 /* copy state */ 1524 zmemcpy((voidpf)dest, (voidpf)source, siz 1525 zmemcpy((voidpf)copy, (voidpf)state, size 1526 copy->strm = dest; 1527 if (state->lencode >= state->codes && 1528 state->lencode <= state->codes + ENOU 1529 copy->lencode = copy->codes + (state- 1530 copy->distcode = copy->codes + (state 1531 } 1532 copy->next = copy->codes + (state->next - 1533 if (window != Z_NULL) { 1534 wsize = 1U << state->wbits; 1535 zmemcpy(window, state->window, wsize) 1536 } 1537 copy->window = window; 1538 dest->state = (struct internal_state FAR 1539 return Z_OK; 1540 } 1541 1542 int ZEXPORT inflateUndermine(strm, subvert) 1543 z_streamp strm; 1544 int subvert; 1545 { 1546 struct inflate_state FAR *state; 1547 1548 if (inflateStateCheck(strm)) return Z_STR 1549 state = (struct inflate_state FAR *)strm- 1550 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ 1551 state->sane = !subvert; 1552 return Z_OK; 1553 #else 1554 (void)subvert; 1555 state->sane = 1; 1556 return Z_DATA_ERROR; 1557 #endif 1558 } 1559 1560 int ZEXPORT inflateValidate(strm, check) 1561 z_streamp strm; 1562 int check; 1563 { 1564 struct inflate_state FAR *state; 1565 1566 if (inflateStateCheck(strm)) return Z_STR 1567 state = (struct inflate_state FAR *)strm- 1568 if (check && state->wrap) 1569 state->wrap |= 4; 1570 else 1571 state->wrap &= ~4; 1572 return Z_OK; 1573 } 1574 1575 long ZEXPORT inflateMark(strm) 1576 z_streamp strm; 1577 { 1578 struct inflate_state FAR *state; 1579 1580 if (inflateStateCheck(strm)) 1581 return -(1L << 16); 1582 state = (struct inflate_state FAR *)strm- 1583 return (long)(((unsigned long)((long)stat 1584 (state->mode == COPY ? state->length 1585 (state->mode == MATCH ? state->wa 1586 } 1587 1588 unsigned long ZEXPORT inflateCodesUsed(strm) 1589 z_streamp strm; 1590 { 1591 struct inflate_state FAR *state; 1592 if (inflateStateCheck(strm)) return (unsi 1593 state = (struct inflate_state FAR *)strm- 1594 return (unsigned long)(state->next - stat 1595 } 1596