inflate.c revision 1.16
1/* inflate.c -- zlib decompression 2 * Copyright (C) 1995-2022 Mark Adler 3 * For conditions of distribution and use, see copyright notice in zlib.h 4 */ 5 6/* 7 * Change history: 8 * 9 * 1.2.beta0 24 Nov 2002 10 * - First version -- complete rewrite of inflate to simplify code, avoid 11 * creation of window when not needed, minimize use of window when it is 12 * needed, make inffast.c even faster, implement gzip decoding, and to 13 * improve code readability and style over the previous zlib inflate code 14 * 15 * 1.2.beta1 25 Nov 2002 16 * - Use pointers for available input and output checking in inffast.c 17 * - Remove input and output counters in inffast.c 18 * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 19 * - Remove unnecessary second byte pull from length extra in inffast.c 20 * - Unroll direct copy to three copies per loop in inffast.c 21 * 22 * 1.2.beta2 4 Dec 2002 23 * - Change external routine names to reduce potential conflicts 24 * - Correct filename to inffixed.h for fixed tables in inflate.c 25 * - Make hbuf[] unsigned char to match parameter type in inflate.c 26 * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) 27 * to avoid negation problem on Alphas (64 bit) in inflate.c 28 * 29 * 1.2.beta3 22 Dec 2002 30 * - Add comments on state->bits assertion in inffast.c 31 * - Add comments on op field in inftrees.h 32 * - Fix bug in reuse of allocated window after inflateReset() 33 * - Remove bit fields--back to byte structure for speed 34 * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths 35 * - Change post-increments to pre-increments in inflate_fast(), PPC biased? 36 * - Add compile time option, POSTINC, to use post-increments instead (Intel?) 37 * - Make MATCH copy in inflate() much faster for when inflate_fast() not used 38 * - Use local copies of stream next and avail values, as well as local bit 39 * buffer and bit count in inflate()--for speed when inflate_fast() not used 40 * 41 * 1.2.beta4 1 Jan 2003 42 * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings 43 * - Move a comment on output buffer sizes from inffast.c to inflate.c 44 * - Add comments in inffast.c to introduce the inflate_fast() routine 45 * - Rearrange window copies in inflate_fast() for speed and simplification 46 * - Unroll last copy for window match in inflate_fast() 47 * - Use local copies of window variables in inflate_fast() for speed 48 * - Pull out common wnext == 0 case for speed in inflate_fast() 49 * - Make op and len in inflate_fast() unsigned for consistency 50 * - Add FAR to lcode and dcode declarations in inflate_fast() 51 * - Simplified bad distance check in inflate_fast() 52 * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new 53 * source file infback.c to provide a call-back interface to inflate for 54 * programs like gzip and unzip -- uses window as output buffer to avoid 55 * window copying 56 * 57 * 1.2.beta5 1 Jan 2003 58 * - Improved inflateBack() interface to allow the caller to provide initial 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 effectiveness of POSTINC 64 * - Typecasting all around to reduce compiler warnings 65 * - Changed loops from while (1) or do {} while (1) to for (;;), again to 66 * make compilers happy 67 * - Changed type of window in inflateBackInit() to unsigned char * 68 * 69 * 1.2.beta7 27 Jan 2003 70 * - Changed many types to unsigned or unsigned short to avoid warnings 71 * - Added inflateCopy() function 72 * 73 * 1.2.0 9 Mar 2003 74 * - Changed inflateBack() interface to provide separate opaque descriptors 75 * for the in() and out() functions 76 * - Changed inflateBack() argument and in_func typedef to swap the length 77 * and buffer address return values for the input function 78 * - Check next_in and next_out for Z_NULL on entry to inflate() 79 * 80 * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. 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 */ 95local int inflateStateCheck OF((z_streamp strm)); 96local void fixedtables OF((struct inflate_state FAR *state)); 97local int updatewindow OF((z_streamp strm, const unsigned char FAR *end, 98 unsigned copy)); 99#ifdef BUILDFIXED 100 void makefixed OF((void)); 101#endif 102local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf, 103 unsigned len)); 104 105local int inflateStateCheck(strm) 106z_streamp strm; 107{ 108 struct inflate_state FAR *state; 109 if (strm == Z_NULL || 110 strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) 111 return 1; 112 state = (struct inflate_state FAR *)strm->state; 113 if (state == Z_NULL || state->strm != strm || 114 state->mode < HEAD || state->mode > SYNC) 115 return 1; 116 return 0; 117} 118 119int ZEXPORT inflateResetKeep(strm) 120z_streamp strm; 121{ 122 struct inflate_state FAR *state; 123 124 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 125 state = (struct inflate_state FAR *)strm->state; 126 strm->total_in = strm->total_out = state->total = 0; 127 strm->msg = Z_NULL; 128 if (state->wrap) /* to support ill-conceived Java test suite */ 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->next = state->codes; 139 state->sane = 1; 140 state->back = -1; 141 Tracev((stderr, "inflate: reset\n")); 142 return Z_OK; 143} 144 145int ZEXPORT inflateReset(strm) 146z_streamp strm; 147{ 148 struct inflate_state FAR *state; 149 150 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 151 state = (struct inflate_state FAR *)strm->state; 152 state->wsize = 0; 153 state->whave = 0; 154 state->wnext = 0; 155 return inflateResetKeep(strm); 156} 157 158int ZEXPORT inflateReset2(strm, windowBits) 159z_streamp strm; 160int windowBits; 161{ 162 int wrap; 163 struct inflate_state FAR *state; 164 165 /* get the state */ 166 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 167 state = (struct inflate_state FAR *)strm->state; 168 169 /* extract wrap request from windowBits parameter */ 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 if different */ 185 if (windowBits && (windowBits < 8 || windowBits > 15)) 186 return Z_STREAM_ERROR; 187 if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { 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 198int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) 199z_streamp strm; 200int windowBits; 201const char *version; 202int stream_size; 203{ 204 int ret; 205 struct inflate_state FAR *state; 206 207 if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || 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 case we return an error */ 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 inflate_state)); 228 if (state == Z_NULL) return Z_MEM_ERROR; 229 Tracev((stderr, "inflate: allocated\n")); 230 strm->state = (struct internal_state FAR *)state; 231 state->strm = strm; 232 state->window = Z_NULL; 233 state->mode = HEAD; /* to pass state test in inflateReset2() */ 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 242int ZEXPORT inflateInit_(strm, version, stream_size) 243z_streamp strm; 244const char *version; 245int stream_size; 246{ 247 return inflateInit2_(strm, DEF_WBITS, version, stream_size); 248} 249 250int ZEXPORT inflatePrime(strm, bits, value) 251z_streamp strm; 252int bits; 253int value; 254{ 255 struct inflate_state FAR *state; 256 257 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 258 state = (struct inflate_state FAR *)strm->state; 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 > 32) return Z_STREAM_ERROR; 265 value &= (1L << bits) - 1; 266 state->hold += (unsigned)value << state->bits; 267 state->bits += (uInt)bits; 268 return Z_OK; 269} 270 271/* 272 Return state with length and distance decoding tables and index sizes set to 273 fixed code decoding. Normally this returns fixed tables from inffixed.h. 274 If BUILDFIXED is defined, then instead this routine builds the tables the 275 first time it's called, and returns those tables the first time and 276 thereafter. This reduces the size of the code by about 2K bytes, in 277 exchange for a little execution time. However, BUILDFIXED should not be 278 used for threaded applications, since the rewriting of the tables and virgin 279 may not be thread-safe. 280 */ 281local void fixedtables(state) 282struct 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 call (may not be thread safe) */ 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++] = 8; 297 while (sym < 256) state->lens[sym++] = 9; 298 while (sym < 280) state->lens[sym++] = 7; 299 while (sym < 288) state->lens[sym++] = 8; 300 next = fixed; 301 lenfix = next; 302 bits = 9; 303 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); 304 305 /* distance table */ 306 sym = 0; 307 while (sym < 32) state->lens[sym++] = 5; 308 distfix = next; 309 bits = 5; 310 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); 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 above. Defining MAKEFIXED also 329 defines BUILDFIXED, so the tables are built on the fly. makefixed() writes 330 those tables to stdout, which would be piped to inffixed.h. A small program 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 with MAKEFIXED defined and run: 342 343 a.out > inffixed.h 344 */ 345void makefixed() 346{ 347 unsigned low, size; 348 struct inflate_state state; 349 350 fixedtables(&state); 351 puts(" /* inffixed.h -- table for decoding fixed codes"); 352 puts(" * Generated automatically by makefixed()."); 353 puts(" */"); 354 puts(""); 355 puts(" /* WARNING: this file should *not* be used by applications."); 356 puts(" It is part of the implementation of this library and is"); 357 puts(" subject to change. Applications should only use zlib.h."); 358 puts(" */"); 359 puts(""); 360 size = 1U << 9; 361 printf(" static const code lenfix[%u] = {", size); 362 low = 0; 363 for (;;) { 364 if ((low % 7) == 0) printf("\n "); 365 printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, 366 state.lencode[low].bits, state.lencode[low].val); 367 if (++low == size) break; 368 putchar(','); 369 } 370 puts("\n };"); 371 size = 1U << 5; 372 printf("\n static const code distfix[%u] = {", size); 373 low = 0; 374 for (;;) { 375 if ((low % 6) == 0) printf("\n "); 376 printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, 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 (normally 32K) bytes written before 387 returning. If window does not exist yet, create it. This is only called 388 when a window is already in use, or when output has been written during this 389 inflate call, but the end of the deflate stream has not been reached yet. 390 It is also called to create a window for dictionary data when a dictionary 391 is loaded. 392 393 Providing output buffers larger than 32K to inflate() should provide a speed 394 advantage, since only the last 32K of output is copied to the sliding window 395 upon return from inflate(), and since all distances after the first 32K of 396 output will fall in the output data, making match copies simpler and faster. 397 The advantage may be dependent on the size of the processor's data caches. 398 */ 399local int updatewindow(strm, end, copy) 400z_streamp strm; 401const Bytef *end; 402unsigned copy; 403{ 404 struct inflate_state FAR *state; 405 unsigned dist; 406 407 state = (struct inflate_state FAR *)strm->state; 408 409 /* if it hasn't been done already, allocate space for the window */ 410 if (state->window == Z_NULL) { 411 state->window = (unsigned char FAR *) 412 ZALLOC(strm, 1U << state->wbits, 413 sizeof(unsigned char)); 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 into the circular window */ 425 if (copy >= state->wsize) { 426 zmemcpy(state->window, end - state->wsize, state->wsize); 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, end - copy, dist); 434 copy -= dist; 435 if (copy) { 436 zmemcpy(state->window, end - copy, copy); 437 state->wnext = copy; 438 state->whave = state->wsize; 439 } 440 else { 441 state->wnext += dist; 442 if (state->wnext == state->wsize) state->wnext = 0; 443 if (state->whave < state->wsize) state->whave += dist; 444 } 445 } 446 return 0; 447} 448 449/* Macros for inflate(): */ 450 451/* check function to use adler32() for zlib or crc32() for gzip */ 452#ifdef GUNZIP 453# define UPDATE_CHECK(check, buf, len) \ 454 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) 455#else 456# define UPDATE_CHECK(check, buf, len) adler32(check, buf, len) 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 speed */ 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 accumulator, or return from inflate() 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++) << bits; \ 514 bits += 8; \ 515 } while (0) 516 517/* Assure that there are at least n bits in the bit accumulator. If there is 518 not enough available input to do that, then return from inflate(). */ 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 accumulator (n < 16) */ 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 to a byte boundary */ 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 as much input data and generate as 545 much output data as possible before returning. The state machine is 546 structured roughly as follows: 547 548 for (;;) switch (state) { 549 ... 550 case STATEn: 551 if (not enough input data or output space to make progress) 552 return; 553 ... make progress ... 554 state = STATEm; 555 break; 556 ... 557 } 558 559 so when inflate() is called again, the same case is attempted again, and 560 if the appropriate resources are provided, the machine proceeds to the 561 next state. The NEEDBITS() macro is usually the way the state evaluates 562 whether it can proceed or should return. NEEDBITS() does the return if 563 the requested bits are not available. The typical use of the BITS macros 564 is: 565 566 NEEDBITS(n); 567 ... do something with BITS(n) ... 568 DROPBITS(n); 569 570 where NEEDBITS(n) either returns from inflate() if there isn't enough 571 input left to load n bits into the accumulator, or it continues. BITS(n) 572 gives the low n bits in the accumulator. When done, DROPBITS(n) drops 573 the low n bits off the accumulator. INITBITS() clears the accumulator 574 and sets the number of available bits to zero. BYTEBITS() discards just 575 enough bits to put the accumulator on a byte boundary. After BYTEBITS() 576 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. 577 578 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return 579 if there is no input available. The decoding of variable length codes uses 580 PULLBYTE() directly in order to pull just enough bytes to decode the next 581 code, and no more. 582 583 Some states loop until they get enough input, making sure that enough 584 state information is maintained to continue the loop where it left off 585 if NEEDBITS() returns in the loop. For example, want, need, and keep 586 would all have to actually be part of the saved state in case NEEDBITS() 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 the next case, then the break 599 is omitted. 600 601 A state may also return if there is not enough output space available to 602 complete that state. Those states are copying stored data, writing a 603 literal byte, and copying a matching string. 604 605 When returning, a "goto inf_leave" is used to update the total counters, 606 update the check value, and determine whether any progress has been made 607 during that inflate() call in order to return the proper return code. 608 Progress is defined as a change in either strm->avail_in or strm->avail_out. 609 When there is a window, goto inf_leave will update the window with the last 610 output written. If a goto inf_leave occurs in the middle of decompression 611 and there is no window currently, goto inf_leave will create one and copy 612 output to the window for the next call of inflate(). 613 614 In this implementation, the flush parameter of inflate() only affects the 615 return code (per zlib.h). inflate() always writes as much as possible to 616 strm->next_out, given the space available and the provided input--the effect 617 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers 618 the allocation of and copying into a sliding window until necessary, which 619 provides the effect documented in zlib.h for Z_FINISH when the entire input 620 stream available. So the only thing the flush parameter actually does is: 621 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it 622 will return Z_BUF_ERROR if it has not reached the end of the stream. 623 */ 624 625int ZEXPORT inflate(strm, flush) 626z_streamp strm; 627int flush; 628{ 629 struct inflate_state FAR *state; 630 z_const unsigned char FAR *next; /* next input */ 631 unsigned char FAR *put; /* next output */ 632 unsigned have, left; /* available input and output */ 633 unsigned long hold; /* bit buffer */ 634 unsigned bits; /* bits in bit buffer */ 635 unsigned in, out; /* save starting available input and output */ 636 unsigned copy; /* number of stored or match bytes to copy */ 637 unsigned char FAR *from; /* where to copy match bytes from */ 638 code here; /* current decoding table entry */ 639 code last; /* parent table entry */ 640 unsigned len; /* length to copy for repeats, bits to drop */ 641 int ret; /* return code */ 642#ifdef GUNZIP 643 unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ 644#endif 645 static const unsigned short order[19] = /* permutation of code lengths */ 646 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; 647 648 if (inflateStateCheck(strm) || strm->next_out == Z_NULL || 649 (strm->next_in == Z_NULL && strm->avail_in != 0)) 650 return Z_STREAM_ERROR; 651 652 state = (struct inflate_state FAR *)strm->state; 653 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ 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 == 0x8b1f) { /* gzip header */ 668 if (state->wbits == 0) 669 state->wbits = 15; 670 state->check = crc32(0L, Z_NULL, 0); 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) || /* check if zlib header allowed */ 679#else 680 if ( 681#endif 682 ((BITS(8) << 8) + (hold >> 8)) % 31) { 683#ifdef SMALL 684 strm->msg = "error"; 685#else 686 strm->msg = (char *)"incorrect header check"; 687#endif 688 state->mode = BAD; 689 break; 690 } 691 if (BITS(4) != Z_DEFLATED) { 692#ifdef SMALL 693 strm->msg = "error"; 694#else 695 strm->msg = (char *)"unknown compression method"; 696#endif 697 state->mode = BAD; 698 break; 699 } 700 DROPBITS(4); 701 len = BITS(4) + 8; 702 if (state->wbits == 0) 703 state->wbits = len; 704 if (len > 15 || len > state->wbits) { 705#ifdef SMALL 706 strm->msg = "error"; 707#else 708 strm->msg = (char *)"invalid window size"; 709#endif 710 state->mode = BAD; 711 break; 712 } 713 state->dmax = 1U << len; 714 state->flags = 0; /* indicate zlib header */ 715 Tracev((stderr, "inflate: zlib header ok\n")); 716 strm->adler = state->check = adler32(0L, Z_NULL, 0); 717 state->mode = hold & 0x200 ? DICTID : TYPE; 718 INITBITS(); 719 break; 720#ifdef GUNZIP 721 case FLAGS: 722 NEEDBITS(16); 723 state->flags = (int)(hold); 724 if ((state->flags & 0xff) != Z_DEFLATED) { 725#ifdef SMALL 726 strm->msg = "error"; 727#else 728 strm->msg = (char *)"unknown compression method"; 729#endif 730 state->mode = BAD; 731 break; 732 } 733 if (state->flags & 0xe000) { 734#ifdef SMALL 735 strm->msg = "error"; 736#else 737 strm->msg = (char *)"unknown header flags set"; 738#endif 739 state->mode = BAD; 740 break; 741 } 742 if (state->head != Z_NULL) 743 state->head->text = (int)((hold >> 8) & 1); 744 if ((state->flags & 0x0200) && (state->wrap & 4)) 745 CRC2(state->check, hold); 746 INITBITS(); 747 state->mode = TIME; 748 /* fallthrough */ 749 case TIME: 750 NEEDBITS(32); 751 if (state->head != Z_NULL) 752 state->head->time = hold; 753 if ((state->flags & 0x0200) && (state->wrap & 4)) 754 CRC4(state->check, hold); 755 INITBITS(); 756 state->mode = OS; 757 /* fallthrough */ 758 case OS: 759 NEEDBITS(16); 760 if (state->head != Z_NULL) { 761 state->head->xflags = (int)(hold & 0xff); 762 state->head->os = (int)(hold >> 8); 763 } 764 if ((state->flags & 0x0200) && (state->wrap & 4)) 765 CRC2(state->check, hold); 766 INITBITS(); 767 state->mode = EXLEN; 768 /* fallthrough */ 769 case EXLEN: 770 if (state->flags & 0x0400) { 771 NEEDBITS(16); 772 state->length = (unsigned)(hold); 773 if (state->head != Z_NULL) 774 state->head->extra_len = (unsigned)hold; 775 if ((state->flags & 0x0200) && (state->wrap & 4)) 776 CRC2(state->check, hold); 777 INITBITS(); 778 } 779 else if (state->head != Z_NULL) 780 state->head->extra = Z_NULL; 781 state->mode = EXTRA; 782 /* fallthrough */ 783 case EXTRA: 784 if (state->flags & 0x0400) { 785 copy = state->length; 786 if (copy > have) copy = have; 787 if (copy) { 788 if (state->head != Z_NULL && 789 state->head->extra != Z_NULL && 790 (len = state->head->extra_len - state->length) < 791 state->head->extra_max) { 792 zmemcpy(state->head->extra + len, next, 793 len + copy > state->head->extra_max ? 794 state->head->extra_max - len : copy); 795 } 796 if ((state->flags & 0x0200) && (state->wrap & 4)) 797 state->check = crc32(state->check, next, copy); 798 have -= copy; 799 next += copy; 800 state->length -= copy; 801 } 802 if (state->length) goto inf_leave; 803 } 804 state->length = 0; 805 state->mode = NAME; 806 /* fallthrough */ 807 case NAME: 808 if (state->flags & 0x0800) { 809 if (have == 0) goto inf_leave; 810 copy = 0; 811 do { 812 len = (unsigned)(next[copy++]); 813 if (state->head != Z_NULL && 814 state->head->name != Z_NULL && 815 state->length < state->head->name_max) 816 state->head->name[state->length++] = (Bytef)len; 817 } while (len && copy < have); 818 if ((state->flags & 0x0200) && (state->wrap & 4)) 819 state->check = crc32(state->check, next, copy); 820 have -= copy; 821 next += copy; 822 if (len) goto inf_leave; 823 } 824 else if (state->head != Z_NULL) 825 state->head->name = Z_NULL; 826 state->length = 0; 827 state->mode = COMMENT; 828 /* fallthrough */ 829 case COMMENT: 830 if (state->flags & 0x1000) { 831 if (have == 0) goto inf_leave; 832 copy = 0; 833 do { 834 len = (unsigned)(next[copy++]); 835 if (state->head != Z_NULL && 836 state->head->comment != Z_NULL && 837 state->length < state->head->comm_max) 838 state->head->comment[state->length++] = (Bytef)len; 839 } while (len && copy < have); 840 if ((state->flags & 0x0200) && (state->wrap & 4)) 841 state->check = crc32(state->check, next, copy); 842 have -= copy; 843 next += copy; 844 if (len) goto inf_leave; 845 } 846 else if (state->head != Z_NULL) 847 state->head->comment = Z_NULL; 848 state->mode = HCRC; 849 /* fallthrough */ 850 case HCRC: 851 if (state->flags & 0x0200) { 852 NEEDBITS(16); 853 if ((state->wrap & 4) && hold != (state->check & 0xffff)) { 854#ifdef SMALL 855 strm->msg = "error"; 856#else 857 strm->msg = (char *)"header crc mismatch"; 858#endif 859 state->mode = BAD; 860 break; 861 } 862 INITBITS(); 863 } 864 if (state->head != Z_NULL) { 865 state->head->hcrc = (int)((state->flags >> 9) & 1); 866 state->head->done = 1; 867 } 868 strm->adler = state->check = crc32(0L, Z_NULL, 0); 869 state->mode = TYPE; 870 break; 871#endif 872 case DICTID: 873 NEEDBITS(32); 874 strm->adler = state->check = ZSWAP32(hold); 875 INITBITS(); 876 state->mode = DICT; 877 /* fallthrough */ 878 case DICT: 879 if (state->havedict == 0) { 880 RESTORE(); 881 return Z_NEED_DICT; 882 } 883 strm->adler = state->check = adler32(0L, Z_NULL, 0); 884 state->mode = TYPE; 885 /* fallthrough */ 886 case TYPE: 887 if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; 888 /* fallthrough */ 889 case TYPEDO: 890 if (state->last) { 891 BYTEBITS(); 892 state->mode = CHECK; 893 break; 894 } 895 NEEDBITS(3); 896 state->last = BITS(1); 897 DROPBITS(1); 898 switch (BITS(2)) { 899 case 0: /* stored block */ 900 Tracev((stderr, "inflate: stored block%s\n", 901 state->last ? " (last)" : "")); 902 state->mode = STORED; 903 break; 904 case 1: /* fixed block */ 905 fixedtables(state); 906 Tracev((stderr, "inflate: fixed codes block%s\n", 907 state->last ? " (last)" : "")); 908 state->mode = LEN_; /* decode codes */ 909 if (flush == Z_TREES) { 910 DROPBITS(2); 911 goto inf_leave; 912 } 913 break; 914 case 2: /* dynamic block */ 915 Tracev((stderr, "inflate: dynamic codes block%s\n", 916 state->last ? " (last)" : "")); 917 state->mode = TABLE; 918 break; 919 case 3: 920#ifdef SMALL 921 strm->msg = "error"; 922#else 923 strm->msg = (char *)"invalid block type"; 924#endif 925 state->mode = BAD; 926 } 927 DROPBITS(2); 928 break; 929 case STORED: 930 BYTEBITS(); /* go to byte boundary */ 931 NEEDBITS(32); 932 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { 933#ifdef SMALL 934 strm->msg = "error"; 935#else 936 strm->msg = (char *)"invalid stored block lengths"; 937#endif 938 state->mode = BAD; 939 break; 940 } 941 state->length = (unsigned)hold & 0xffff; 942 Tracev((stderr, "inflate: stored length %u\n", 943 state->length)); 944 INITBITS(); 945 state->mode = COPY_; 946 if (flush == Z_TREES) goto inf_leave; 947 /* fallthrough */ 948 case COPY_: 949 state->mode = COPY; 950 /* fallthrough */ 951 case COPY: 952 copy = state->length; 953 if (copy) { 954 if (copy > have) copy = have; 955 if (copy > left) copy = left; 956 if (copy == 0) goto inf_leave; 957 zmemcpy(put, next, copy); 958 have -= copy; 959 next += copy; 960 left -= copy; 961 put += copy; 962 state->length -= copy; 963 break; 964 } 965 Tracev((stderr, "inflate: stored end\n")); 966 state->mode = TYPE; 967 break; 968 case TABLE: 969 NEEDBITS(14); 970 state->nlen = BITS(5) + 257; 971 DROPBITS(5); 972 state->ndist = BITS(5) + 1; 973 DROPBITS(5); 974 state->ncode = BITS(4) + 4; 975 DROPBITS(4); 976#ifndef PKZIP_BUG_WORKAROUND 977 if (state->nlen > 286 || state->ndist > 30) { 978#ifdef SMALL 979 strm->msg = "error"; 980#else 981 strm->msg = (char *)"too many length or distance symbols"; 982#endif 983 state->mode = BAD; 984 break; 985 } 986#endif 987 Tracev((stderr, "inflate: table sizes ok\n")); 988 state->have = 0; 989 state->mode = LENLENS; 990 /* fallthrough */ 991 case LENLENS: 992 while (state->have < state->ncode) { 993 NEEDBITS(3); 994 state->lens[order[state->have++]] = (unsigned short)BITS(3); 995 DROPBITS(3); 996 } 997 while (state->have < 19) 998 state->lens[order[state->have++]] = 0; 999 state->next = state->codes; 1000 state->lencode = (const code FAR *)(state->next); 1001 state->lenbits = 7; 1002 ret = inflate_table(CODES, state->lens, 19, &(state->next), 1003 &(state->lenbits), state->work); 1004 if (ret) { 1005#ifdef SMALL 1006 strm->msg = "error"; 1007#else 1008 strm->msg = (char *)"invalid code lengths set"; 1009#endif 1010 state->mode = BAD; 1011 break; 1012 } 1013 Tracev((stderr, "inflate: code lengths ok\n")); 1014 state->have = 0; 1015 state->mode = CODELENS; 1016 /* fallthrough */ 1017 case CODELENS: 1018 while (state->have < state->nlen + state->ndist) { 1019 for (;;) { 1020 here = state->lencode[BITS(state->lenbits)]; 1021 if ((unsigned)(here.bits) <= bits) break; 1022 PULLBYTE(); 1023 } 1024 if (here.val < 16) { 1025 DROPBITS(here.bits); 1026 state->lens[state->have++] = here.val; 1027 } 1028 else { 1029 if (here.val == 16) { 1030 NEEDBITS(here.bits + 2); 1031 DROPBITS(here.bits); 1032 if (state->have == 0) { 1033#ifdef SMALL 1034 strm->msg = "error"; 1035#else 1036 strm->msg = (char *)"invalid bit length repeat"; 1037#endif 1038 state->mode = BAD; 1039 break; 1040 } 1041 len = state->lens[state->have - 1]; 1042 copy = 3 + BITS(2); 1043 DROPBITS(2); 1044 } 1045 else if (here.val == 17) { 1046 NEEDBITS(here.bits + 3); 1047 DROPBITS(here.bits); 1048 len = 0; 1049 copy = 3 + BITS(3); 1050 DROPBITS(3); 1051 } 1052 else { 1053 NEEDBITS(here.bits + 7); 1054 DROPBITS(here.bits); 1055 len = 0; 1056 copy = 11 + BITS(7); 1057 DROPBITS(7); 1058 } 1059 if (state->have + copy > state->nlen + state->ndist) { 1060#ifdef SMALL 1061 strm->msg = "error"; 1062#else 1063 strm->msg = (char *)"invalid bit length repeat"; 1064#endif 1065 state->mode = BAD; 1066 break; 1067 } 1068 while (copy--) 1069 state->lens[state->have++] = (unsigned short)len; 1070 } 1071 } 1072 1073 /* handle error breaks in while */ 1074 if (state->mode == BAD) break; 1075 1076 /* check for end-of-block code (better have one) */ 1077 if (state->lens[256] == 0) { 1078#ifdef SMALL 1079 strm->msg = "error"; 1080#else 1081 strm->msg = (char *)"invalid code -- missing end-of-block"; 1082#endif 1083 state->mode = BAD; 1084 break; 1085 } 1086 1087 /* build code tables -- note: do not change the lenbits or distbits 1088 values here (9 and 6) without reading the comments in inftrees.h 1089 concerning the ENOUGH constants, which depend on those values */ 1090 state->next = state->codes; 1091 state->lencode = (const code FAR *)(state->next); 1092 state->lenbits = 9; 1093 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), 1094 &(state->lenbits), state->work); 1095 if (ret) { 1096#ifdef SMALL 1097 strm->msg = "error"; 1098#else 1099 strm->msg = (char *)"invalid literal/lengths set"; 1100#endif 1101 state->mode = BAD; 1102 break; 1103 } 1104 state->distcode = (const code FAR *)(state->next); 1105 state->distbits = 6; 1106 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, 1107 &(state->next), &(state->distbits), state->work); 1108 if (ret) { 1109#ifdef SMALL 1110 strm->msg = "error"; 1111#else 1112 strm->msg = (char *)"invalid distances set"; 1113#endif 1114 state->mode = BAD; 1115 break; 1116 } 1117 Tracev((stderr, "inflate: codes ok\n")); 1118 state->mode = LEN_; 1119 if (flush == Z_TREES) goto inf_leave; 1120 /* fallthrough */ 1121 case LEN_: 1122 state->mode = LEN; 1123 /* fallthrough */ 1124 case LEN: 1125#ifndef SLOW 1126 if (have >= 6 && left >= 258) { 1127 RESTORE(); 1128 inflate_fast(strm, out); 1129 LOAD(); 1130 if (state->mode == TYPE) 1131 state->back = -1; 1132 break; 1133 } 1134#endif 1135 state->back = 0; 1136 for (;;) { 1137 here = state->lencode[BITS(state->lenbits)]; 1138 if ((unsigned)(here.bits) <= bits) break; 1139 PULLBYTE(); 1140 } 1141 if (here.op && (here.op & 0xf0) == 0) { 1142 last = here; 1143 for (;;) { 1144 here = state->lencode[last.val + 1145 (BITS(last.bits + last.op) >> last.bits)]; 1146 if ((unsigned)(last.bits + here.bits) <= bits) break; 1147 PULLBYTE(); 1148 } 1149 DROPBITS(last.bits); 1150 state->back += last.bits; 1151 } 1152 DROPBITS(here.bits); 1153 state->back += here.bits; 1154 state->length = (unsigned)here.val; 1155 if ((int)(here.op) == 0) { 1156 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? 1157 "inflate: literal '%c'\n" : 1158 "inflate: literal 0x%02x\n", here.val)); 1159 state->mode = LIT; 1160 break; 1161 } 1162 if (here.op & 32) { 1163 Tracevv((stderr, "inflate: end of block\n")); 1164 state->back = -1; 1165 state->mode = TYPE; 1166 break; 1167 } 1168 if (here.op & 64) { 1169#ifdef SMALL 1170 strm->msg = "error"; 1171#else 1172 strm->msg = (char *)"invalid literal/length code"; 1173#endif 1174 state->mode = BAD; 1175 break; 1176 } 1177 state->extra = (unsigned)(here.op) & 15; 1178 state->mode = LENEXT; 1179 /* fallthrough */ 1180 case LENEXT: 1181 if (state->extra) { 1182 NEEDBITS(state->extra); 1183 state->length += BITS(state->extra); 1184 DROPBITS(state->extra); 1185 state->back += state->extra; 1186 } 1187 Tracevv((stderr, "inflate: length %u\n", state->length)); 1188 state->was = state->length; 1189 state->mode = DIST; 1190 /* fallthrough */ 1191 case DIST: 1192 for (;;) { 1193 here = state->distcode[BITS(state->distbits)]; 1194 if ((unsigned)(here.bits) <= bits) break; 1195 PULLBYTE(); 1196 } 1197 if ((here.op & 0xf0) == 0) { 1198 last = here; 1199 for (;;) { 1200 here = state->distcode[last.val + 1201 (BITS(last.bits + last.op) >> last.bits)]; 1202 if ((unsigned)(last.bits + here.bits) <= bits) break; 1203 PULLBYTE(); 1204 } 1205 DROPBITS(last.bits); 1206 state->back += last.bits; 1207 } 1208 DROPBITS(here.bits); 1209 state->back += here.bits; 1210 if (here.op & 64) { 1211#ifdef SMALL 1212 strm->msg = "error"; 1213#else 1214 strm->msg = (char *)"invalid distance code"; 1215#endif 1216 state->mode = BAD; 1217 break; 1218 } 1219 state->offset = (unsigned)here.val; 1220 state->extra = (unsigned)(here.op) & 15; 1221 state->mode = DISTEXT; 1222 /* fallthrough */ 1223 case DISTEXT: 1224 if (state->extra) { 1225 NEEDBITS(state->extra); 1226 state->offset += BITS(state->extra); 1227 DROPBITS(state->extra); 1228 state->back += state->extra; 1229 } 1230#ifdef INFLATE_STRICT 1231 if (state->offset > state->dmax) { 1232#ifdef SMALL 1233 strm->msg = "error"; 1234#else 1235 strm->msg = (char *)"invalid distance too far back"; 1236#endif 1237 state->mode = BAD; 1238 break; 1239 } 1240#endif 1241 Tracevv((stderr, "inflate: distance %u\n", state->offset)); 1242 state->mode = MATCH; 1243 /* fallthrough */ 1244 case MATCH: 1245 if (left == 0) goto inf_leave; 1246 copy = out - left; 1247 if (state->offset > copy) { /* copy from window */ 1248 copy = state->offset - copy; 1249 if (copy > state->whave) { 1250 if (state->sane) { 1251#ifdef SMALL 1252 strm->msg = "error"; 1253#else 1254 strm->msg = (char *)"invalid distance too far back"; 1255#endif 1256 state->mode = BAD; 1257 break; 1258 } 1259#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR 1260 Trace((stderr, "inflate.c too far\n")); 1261 copy -= state->whave; 1262 if (copy > state->length) copy = state->length; 1263 if (copy > left) copy = left; 1264 left -= copy; 1265 state->length -= copy; 1266 do { 1267 *put++ = 0; 1268 } while (--copy); 1269 if (state->length == 0) state->mode = LEN; 1270 break; 1271#endif 1272 } 1273 if (copy > state->wnext) { 1274 copy -= state->wnext; 1275 from = state->window + (state->wsize - copy); 1276 } 1277 else 1278 from = state->window + (state->wnext - copy); 1279 if (copy > state->length) copy = state->length; 1280 } 1281 else { /* copy from output */ 1282 from = put - state->offset; 1283 copy = state->length; 1284 } 1285 if (copy > left) copy = left; 1286 left -= copy; 1287 state->length -= copy; 1288 do { 1289 *put++ = *from++; 1290 } while (--copy); 1291 if (state->length == 0) state->mode = LEN; 1292 break; 1293 case LIT: 1294 if (left == 0) goto inf_leave; 1295 *put++ = (unsigned char)(state->length); 1296 left--; 1297 state->mode = LEN; 1298 break; 1299 case CHECK: 1300 if (state->wrap) { 1301 NEEDBITS(32); 1302 out -= left; 1303 strm->total_out += out; 1304 state->total += out; 1305 if ((state->wrap & 4) && out) 1306 strm->adler = state->check = 1307 UPDATE_CHECK(state->check, put - out, out); 1308 out = left; 1309 if ((state->wrap & 4) && ( 1310#ifdef GUNZIP 1311 state->flags ? hold : 1312#endif 1313 ZSWAP32(hold)) != state->check) { 1314#ifdef SMALL 1315 strm->msg = "error"; 1316#else 1317 strm->msg = (char *)"incorrect data check"; 1318#endif 1319 state->mode = BAD; 1320 break; 1321 } 1322 INITBITS(); 1323 Tracev((stderr, "inflate: check matches trailer\n")); 1324 } 1325#ifdef GUNZIP 1326 state->mode = LENGTH; 1327 /* fallthrough */ 1328 case LENGTH: 1329 if (state->wrap && state->flags) { 1330 NEEDBITS(32); 1331 if ((state->wrap & 4) && hold != (state->total & 0xffffffff)) { 1332#ifdef SMALL 1333 strm->msg = "error"; 1334#else 1335 strm->msg = (char *)"incorrect length check"; 1336#endif 1337 state->mode = BAD; 1338 break; 1339 } 1340 INITBITS(); 1341 Tracev((stderr, "inflate: length matches trailer\n")); 1342 } 1343#endif 1344 state->mode = DONE; 1345 /* fallthrough */ 1346 case DONE: 1347 ret = Z_STREAM_END; 1348 goto inf_leave; 1349 case BAD: 1350 ret = Z_DATA_ERROR; 1351 goto inf_leave; 1352 case MEM: 1353 return Z_MEM_ERROR; 1354 case SYNC: 1355 /* fallthrough */ 1356 default: 1357 return Z_STREAM_ERROR; 1358 } 1359 1360 /* 1361 Return from inflate(), updating the total counts and the check value. 1362 If there was no progress during the inflate() call, return a buffer 1363 error. Call updatewindow() to create and/or update the window state. 1364 Note: a memory error from inflate() is non-recoverable. 1365 */ 1366 inf_leave: 1367 RESTORE(); 1368 if (state->wsize || (out != strm->avail_out && state->mode < BAD && 1369 (state->mode < CHECK || flush != Z_FINISH))) 1370 if (updatewindow(strm, strm->next_out, out - strm->avail_out)) { 1371 state->mode = MEM; 1372 return Z_MEM_ERROR; 1373 } 1374 in -= strm->avail_in; 1375 out -= strm->avail_out; 1376 strm->total_in += in; 1377 strm->total_out += out; 1378 state->total += out; 1379 if ((state->wrap & 4) && out) 1380 strm->adler = state->check = 1381 UPDATE_CHECK(state->check, strm->next_out - out, out); 1382 strm->data_type = (int)state->bits + (state->last ? 64 : 0) + 1383 (state->mode == TYPE ? 128 : 0) + 1384 (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); 1385 if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) 1386 ret = Z_BUF_ERROR; 1387 return ret; 1388} 1389 1390int ZEXPORT inflateEnd(strm) 1391z_streamp strm; 1392{ 1393 struct inflate_state FAR *state; 1394 if (inflateStateCheck(strm)) 1395 return Z_STREAM_ERROR; 1396 state = (struct inflate_state FAR *)strm->state; 1397 if (state->window != Z_NULL) ZFREE(strm, state->window); 1398 ZFREE(strm, strm->state); 1399 strm->state = Z_NULL; 1400 Tracev((stderr, "inflate: end\n")); 1401 return Z_OK; 1402} 1403 1404int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength) 1405z_streamp strm; 1406Bytef *dictionary; 1407uInt *dictLength; 1408{ 1409 struct inflate_state FAR *state; 1410 1411 /* check state */ 1412 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1413 state = (struct inflate_state FAR *)strm->state; 1414 1415 /* copy dictionary */ 1416 if (state->whave && dictionary != Z_NULL) { 1417 zmemcpy(dictionary, state->window + state->wnext, 1418 state->whave - state->wnext); 1419 zmemcpy(dictionary + state->whave - state->wnext, 1420 state->window, state->wnext); 1421 } 1422 if (dictLength != Z_NULL) 1423 *dictLength = state->whave; 1424 return Z_OK; 1425} 1426 1427int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) 1428z_streamp strm; 1429const Bytef *dictionary; 1430uInt dictLength; 1431{ 1432 struct inflate_state FAR *state; 1433 unsigned long dictid; 1434 int ret; 1435 1436 /* check state */ 1437 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1438 state = (struct inflate_state FAR *)strm->state; 1439 if (state->wrap != 0 && state->mode != DICT) 1440 return Z_STREAM_ERROR; 1441 1442 /* check for correct dictionary identifier */ 1443 if (state->mode == DICT) { 1444 dictid = adler32(0L, Z_NULL, 0); 1445 dictid = adler32(dictid, dictionary, dictLength); 1446 if (dictid != state->check) 1447 return Z_DATA_ERROR; 1448 } 1449 1450 /* copy dictionary to window using updatewindow(), which will amend the 1451 existing dictionary if appropriate */ 1452 ret = updatewindow(strm, dictionary + dictLength, dictLength); 1453 if (ret) { 1454 state->mode = MEM; 1455 return Z_MEM_ERROR; 1456 } 1457 state->havedict = 1; 1458 Tracev((stderr, "inflate: dictionary set\n")); 1459 return Z_OK; 1460} 1461 1462int ZEXPORT inflateGetHeader(strm, head) 1463z_streamp strm; 1464gz_headerp head; 1465{ 1466 struct inflate_state FAR *state; 1467 1468 /* check state */ 1469 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1470 state = (struct inflate_state FAR *)strm->state; 1471 if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; 1472 1473 /* save header structure */ 1474 state->head = head; 1475 head->done = 0; 1476 return Z_OK; 1477} 1478 1479/* 1480 Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found 1481 or when out of input. When called, *have is the number of pattern bytes 1482 found in order so far, in 0..3. On return *have is updated to the new 1483 state. If on return *have equals four, then the pattern was found and the 1484 return value is how many bytes were read including the last byte of the 1485 pattern. If *have is less than four, then the pattern has not been found 1486 yet and the return value is len. In the latter case, syncsearch() can be 1487 called again with more data and the *have state. *have is initialized to 1488 zero for the first call. 1489 */ 1490local unsigned syncsearch(have, buf, len) 1491unsigned FAR *have; 1492const unsigned char FAR *buf; 1493unsigned len; 1494{ 1495 unsigned got; 1496 unsigned next; 1497 1498 got = *have; 1499 next = 0; 1500 while (next < len && got < 4) { 1501 if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) 1502 got++; 1503 else if (buf[next]) 1504 got = 0; 1505 else 1506 got = 4 - got; 1507 next++; 1508 } 1509 *have = got; 1510 return next; 1511} 1512 1513int ZEXPORT inflateSync(strm) 1514z_streamp strm; 1515{ 1516 unsigned len; /* number of bytes to look at or looked at */ 1517 int flags; /* temporary to save header status */ 1518 unsigned long in, out; /* temporary to save total_in and total_out */ 1519 unsigned char buf[4]; /* to restore bit buffer to byte string */ 1520 struct inflate_state FAR *state; 1521 1522 /* check parameters */ 1523 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1524 state = (struct inflate_state FAR *)strm->state; 1525 if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; 1526 1527 /* if first time, start search in bit buffer */ 1528 if (state->mode != SYNC) { 1529 state->mode = SYNC; 1530 state->hold <<= state->bits & 7; 1531 state->bits -= state->bits & 7; 1532 len = 0; 1533 while (state->bits >= 8) { 1534 buf[len++] = (unsigned char)(state->hold); 1535 state->hold >>= 8; 1536 state->bits -= 8; 1537 } 1538 state->have = 0; 1539 syncsearch(&(state->have), buf, len); 1540 } 1541 1542 /* search available input */ 1543 len = syncsearch(&(state->have), strm->next_in, strm->avail_in); 1544 strm->avail_in -= len; 1545 strm->next_in += len; 1546 strm->total_in += len; 1547 1548 /* return no joy or set up to restart inflate() on a new block */ 1549 if (state->have != 4) return Z_DATA_ERROR; 1550 if (state->flags == -1) 1551 state->wrap = 0; /* if no header yet, treat as raw */ 1552 else 1553 state->wrap &= ~4; /* no point in computing a check value now */ 1554 flags = state->flags; 1555 in = strm->total_in; out = strm->total_out; 1556 inflateReset(strm); 1557 strm->total_in = in; strm->total_out = out; 1558 state->flags = flags; 1559 state->mode = TYPE; 1560 return Z_OK; 1561} 1562 1563/* 1564 Returns true if inflate is currently at the end of a block generated by 1565 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP 1566 implementation to provide an additional safety check. PPP uses 1567 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored 1568 block. When decompressing, PPP checks that at the end of input packet, 1569 inflate is waiting for these length bytes. 1570 */ 1571int ZEXPORT inflateSyncPoint(strm) 1572z_streamp strm; 1573{ 1574 struct inflate_state FAR *state; 1575 1576 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1577 state = (struct inflate_state FAR *)strm->state; 1578 return state->mode == STORED && state->bits == 0; 1579} 1580 1581int ZEXPORT inflateCopy(dest, source) 1582z_streamp dest; 1583z_streamp source; 1584{ 1585 struct inflate_state FAR *state; 1586 struct inflate_state FAR *copy; 1587 unsigned char FAR *window; 1588 unsigned wsize; 1589 1590 /* check input */ 1591 if (inflateStateCheck(source) || dest == Z_NULL) 1592 return Z_STREAM_ERROR; 1593 state = (struct inflate_state FAR *)source->state; 1594 1595 /* allocate space */ 1596 copy = (struct inflate_state FAR *) 1597 ZALLOC(source, 1, sizeof(struct inflate_state)); 1598 if (copy == Z_NULL) return Z_MEM_ERROR; 1599 window = Z_NULL; 1600 if (state->window != Z_NULL) { 1601 window = (unsigned char FAR *) 1602 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); 1603 if (window == Z_NULL) { 1604 ZFREE(source, copy); 1605 return Z_MEM_ERROR; 1606 } 1607 } 1608 1609 /* copy state */ 1610 zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); 1611 zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state)); 1612 copy->strm = dest; 1613 if (state->lencode >= state->codes && 1614 state->lencode <= state->codes + ENOUGH - 1) { 1615 copy->lencode = copy->codes + (state->lencode - state->codes); 1616 copy->distcode = copy->codes + (state->distcode - state->codes); 1617 } 1618 copy->next = copy->codes + (state->next - state->codes); 1619 if (window != Z_NULL) { 1620 wsize = 1U << state->wbits; 1621 zmemcpy(window, state->window, wsize); 1622 } 1623 copy->window = window; 1624 dest->state = (struct internal_state FAR *)copy; 1625 return Z_OK; 1626} 1627 1628int ZEXPORT inflateUndermine(strm, subvert) 1629z_streamp strm; 1630int subvert; 1631{ 1632 struct inflate_state FAR *state; 1633 1634 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1635 state = (struct inflate_state FAR *)strm->state; 1636#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR 1637 state->sane = !subvert; 1638 return Z_OK; 1639#else 1640 (void)subvert; 1641 state->sane = 1; 1642 return Z_DATA_ERROR; 1643#endif 1644} 1645 1646int ZEXPORT inflateValidate(strm, check) 1647z_streamp strm; 1648int check; 1649{ 1650 struct inflate_state FAR *state; 1651 1652 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1653 state = (struct inflate_state FAR *)strm->state; 1654 if (check && state->wrap) 1655 state->wrap |= 4; 1656 else 1657 state->wrap &= ~4; 1658 return Z_OK; 1659} 1660 1661long ZEXPORT inflateMark(strm) 1662z_streamp strm; 1663{ 1664 struct inflate_state FAR *state; 1665 1666 if (inflateStateCheck(strm)) 1667 return -(1L << 16); 1668 state = (struct inflate_state FAR *)strm->state; 1669 return (long)(((unsigned long)((long)state->back)) << 16) + 1670 (state->mode == COPY ? state->length : 1671 (state->mode == MATCH ? state->was - state->length : 0)); 1672} 1673 1674unsigned long ZEXPORT inflateCodesUsed(strm) 1675z_streamp strm; 1676{ 1677 struct inflate_state FAR *state; 1678 if (inflateStateCheck(strm)) return (unsigned long)-1; 1679 state = (struct inflate_state FAR *)strm->state; 1680 return (unsigned long)(state->next - state->codes); 1681} 1682