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