inflate.c revision 1.14
1/* $OpenBSD: inflate.c,v 1.14 2022/08/15 12:29:19 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 state->head->extra_max) { 791 zmemcpy(state->head->extra + len, next, 792 len + copy > state->head->extra_max ? 793 state->head->extra_max - len : copy); 794 } 795 if ((state->flags & 0x0200) && (state->wrap & 4)) 796 state->check = crc32(state->check, next, copy); 797 have -= copy; 798 next += copy; 799 state->length -= copy; 800 } 801 if (state->length) goto inf_leave; 802 } 803 state->length = 0; 804 state->mode = NAME; 805 /* fallthrough */ 806 case NAME: 807 if (state->flags & 0x0800) { 808 if (have == 0) goto inf_leave; 809 copy = 0; 810 do { 811 len = (unsigned)(next[copy++]); 812 if (state->head != Z_NULL && 813 state->head->name != Z_NULL && 814 state->length < state->head->name_max) 815 state->head->name[state->length++] = (Bytef)len; 816 } while (len && copy < have); 817 if ((state->flags & 0x0200) && (state->wrap & 4)) 818 state->check = crc32(state->check, next, copy); 819 have -= copy; 820 next += copy; 821 if (len) goto inf_leave; 822 } 823 else if (state->head != Z_NULL) 824 state->head->name = Z_NULL; 825 state->length = 0; 826 state->mode = COMMENT; 827 /* fallthrough */ 828 case COMMENT: 829 if (state->flags & 0x1000) { 830 if (have == 0) goto inf_leave; 831 copy = 0; 832 do { 833 len = (unsigned)(next[copy++]); 834 if (state->head != Z_NULL && 835 state->head->comment != Z_NULL && 836 state->length < state->head->comm_max) 837 state->head->comment[state->length++] = (Bytef)len; 838 } while (len && copy < have); 839 if ((state->flags & 0x0200) && (state->wrap & 4)) 840 state->check = crc32(state->check, next, copy); 841 have -= copy; 842 next += copy; 843 if (len) goto inf_leave; 844 } 845 else if (state->head != Z_NULL) 846 state->head->comment = Z_NULL; 847 state->mode = HCRC; 848 /* fallthrough */ 849 case HCRC: 850 if (state->flags & 0x0200) { 851 NEEDBITS(16); 852 if ((state->wrap & 4) && hold != (state->check & 0xffff)) { 853#ifdef SMALL 854 strm->msg = "error"; 855#else 856 strm->msg = (char *)"header crc mismatch"; 857#endif 858 state->mode = BAD; 859 break; 860 } 861 INITBITS(); 862 } 863 if (state->head != Z_NULL) { 864 state->head->hcrc = (int)((state->flags >> 9) & 1); 865 state->head->done = 1; 866 } 867 strm->adler = state->check = crc32(0L, Z_NULL, 0); 868 state->mode = TYPE; 869 break; 870#endif 871 case DICTID: 872 NEEDBITS(32); 873 strm->adler = state->check = ZSWAP32(hold); 874 INITBITS(); 875 state->mode = DICT; 876 /* fallthrough */ 877 case DICT: 878 if (state->havedict == 0) { 879 RESTORE(); 880 return Z_NEED_DICT; 881 } 882 strm->adler = state->check = adler32(0L, Z_NULL, 0); 883 state->mode = TYPE; 884 /* fallthrough */ 885 case TYPE: 886 if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; 887 /* fallthrough */ 888 case TYPEDO: 889 if (state->last) { 890 BYTEBITS(); 891 state->mode = CHECK; 892 break; 893 } 894 NEEDBITS(3); 895 state->last = BITS(1); 896 DROPBITS(1); 897 switch (BITS(2)) { 898 case 0: /* stored block */ 899 Tracev((stderr, "inflate: stored block%s\n", 900 state->last ? " (last)" : "")); 901 state->mode = STORED; 902 break; 903 case 1: /* fixed block */ 904 fixedtables(state); 905 Tracev((stderr, "inflate: fixed codes block%s\n", 906 state->last ? " (last)" : "")); 907 state->mode = LEN_; /* decode codes */ 908 if (flush == Z_TREES) { 909 DROPBITS(2); 910 goto inf_leave; 911 } 912 break; 913 case 2: /* dynamic block */ 914 Tracev((stderr, "inflate: dynamic codes block%s\n", 915 state->last ? " (last)" : "")); 916 state->mode = TABLE; 917 break; 918 case 3: 919#ifdef SMALL 920 strm->msg = "error"; 921#else 922 strm->msg = (char *)"invalid block type"; 923#endif 924 state->mode = BAD; 925 } 926 DROPBITS(2); 927 break; 928 case STORED: 929 BYTEBITS(); /* go to byte boundary */ 930 NEEDBITS(32); 931 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { 932#ifdef SMALL 933 strm->msg = "error"; 934#else 935 strm->msg = (char *)"invalid stored block lengths"; 936#endif 937 state->mode = BAD; 938 break; 939 } 940 state->length = (unsigned)hold & 0xffff; 941 Tracev((stderr, "inflate: stored length %u\n", 942 state->length)); 943 INITBITS(); 944 state->mode = COPY_; 945 if (flush == Z_TREES) goto inf_leave; 946 /* fallthrough */ 947 case COPY_: 948 state->mode = COPY; 949 /* fallthrough */ 950 case COPY: 951 copy = state->length; 952 if (copy) { 953 if (copy > have) copy = have; 954 if (copy > left) copy = left; 955 if (copy == 0) goto inf_leave; 956 zmemcpy(put, next, copy); 957 have -= copy; 958 next += copy; 959 left -= copy; 960 put += copy; 961 state->length -= copy; 962 break; 963 } 964 Tracev((stderr, "inflate: stored end\n")); 965 state->mode = TYPE; 966 break; 967 case TABLE: 968 NEEDBITS(14); 969 state->nlen = BITS(5) + 257; 970 DROPBITS(5); 971 state->ndist = BITS(5) + 1; 972 DROPBITS(5); 973 state->ncode = BITS(4) + 4; 974 DROPBITS(4); 975#ifndef PKZIP_BUG_WORKAROUND 976 if (state->nlen > 286 || state->ndist > 30) { 977#ifdef SMALL 978 strm->msg = "error"; 979#else 980 strm->msg = (char *)"too many length or distance symbols"; 981#endif 982 state->mode = BAD; 983 break; 984 } 985#endif 986 Tracev((stderr, "inflate: table sizes ok\n")); 987 state->have = 0; 988 state->mode = LENLENS; 989 /* fallthrough */ 990 case LENLENS: 991 while (state->have < state->ncode) { 992 NEEDBITS(3); 993 state->lens[order[state->have++]] = (unsigned short)BITS(3); 994 DROPBITS(3); 995 } 996 while (state->have < 19) 997 state->lens[order[state->have++]] = 0; 998 state->next = state->codes; 999 state->lencode = (const code FAR *)(state->next); 1000 state->lenbits = 7; 1001 ret = inflate_table(CODES, state->lens, 19, &(state->next), 1002 &(state->lenbits), state->work); 1003 if (ret) { 1004#ifdef SMALL 1005 strm->msg = "error"; 1006#else 1007 strm->msg = (char *)"invalid code lengths set"; 1008#endif 1009 state->mode = BAD; 1010 break; 1011 } 1012 Tracev((stderr, "inflate: code lengths ok\n")); 1013 state->have = 0; 1014 state->mode = CODELENS; 1015 /* fallthrough */ 1016 case CODELENS: 1017 while (state->have < state->nlen + state->ndist) { 1018 for (;;) { 1019 here = state->lencode[BITS(state->lenbits)]; 1020 if ((unsigned)(here.bits) <= bits) break; 1021 PULLBYTE(); 1022 } 1023 if (here.val < 16) { 1024 DROPBITS(here.bits); 1025 state->lens[state->have++] = here.val; 1026 } 1027 else { 1028 if (here.val == 16) { 1029 NEEDBITS(here.bits + 2); 1030 DROPBITS(here.bits); 1031 if (state->have == 0) { 1032#ifdef SMALL 1033 strm->msg = "error"; 1034#else 1035 strm->msg = (char *)"invalid bit length repeat"; 1036#endif 1037 state->mode = BAD; 1038 break; 1039 } 1040 len = state->lens[state->have - 1]; 1041 copy = 3 + BITS(2); 1042 DROPBITS(2); 1043 } 1044 else if (here.val == 17) { 1045 NEEDBITS(here.bits + 3); 1046 DROPBITS(here.bits); 1047 len = 0; 1048 copy = 3 + BITS(3); 1049 DROPBITS(3); 1050 } 1051 else { 1052 NEEDBITS(here.bits + 7); 1053 DROPBITS(here.bits); 1054 len = 0; 1055 copy = 11 + BITS(7); 1056 DROPBITS(7); 1057 } 1058 if (state->have + copy > state->nlen + state->ndist) { 1059#ifdef SMALL 1060 strm->msg = "error"; 1061#else 1062 strm->msg = (char *)"invalid bit length repeat"; 1063#endif 1064 state->mode = BAD; 1065 break; 1066 } 1067 while (copy--) 1068 state->lens[state->have++] = (unsigned short)len; 1069 } 1070 } 1071 1072 /* handle error breaks in while */ 1073 if (state->mode == BAD) break; 1074 1075 /* check for end-of-block code (better have one) */ 1076 if (state->lens[256] == 0) { 1077#ifdef SMALL 1078 strm->msg = "error"; 1079#else 1080 strm->msg = (char *)"invalid code -- missing end-of-block"; 1081#endif 1082 state->mode = BAD; 1083 break; 1084 } 1085 1086 /* build code tables -- note: do not change the lenbits or distbits 1087 values here (9 and 6) without reading the comments in inftrees.h 1088 concerning the ENOUGH constants, which depend on those values */ 1089 state->next = state->codes; 1090 state->lencode = (const code FAR *)(state->next); 1091 state->lenbits = 9; 1092 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), 1093 &(state->lenbits), state->work); 1094 if (ret) { 1095#ifdef SMALL 1096 strm->msg = "error"; 1097#else 1098 strm->msg = (char *)"invalid literal/lengths set"; 1099#endif 1100 state->mode = BAD; 1101 break; 1102 } 1103 state->distcode = (const code FAR *)(state->next); 1104 state->distbits = 6; 1105 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, 1106 &(state->next), &(state->distbits), state->work); 1107 if (ret) { 1108#ifdef SMALL 1109 strm->msg = "error"; 1110#else 1111 strm->msg = (char *)"invalid distances set"; 1112#endif 1113 state->mode = BAD; 1114 break; 1115 } 1116 Tracev((stderr, "inflate: codes ok\n")); 1117 state->mode = LEN_; 1118 if (flush == Z_TREES) goto inf_leave; 1119 /* fallthrough */ 1120 case LEN_: 1121 state->mode = LEN; 1122 /* fallthrough */ 1123 case LEN: 1124#ifndef SLOW 1125 if (have >= 6 && left >= 258) { 1126 RESTORE(); 1127 inflate_fast(strm, out); 1128 LOAD(); 1129 if (state->mode == TYPE) 1130 state->back = -1; 1131 break; 1132 } 1133#endif 1134 state->back = 0; 1135 for (;;) { 1136 here = state->lencode[BITS(state->lenbits)]; 1137 if ((unsigned)(here.bits) <= bits) break; 1138 PULLBYTE(); 1139 } 1140 if (here.op && (here.op & 0xf0) == 0) { 1141 last = here; 1142 for (;;) { 1143 here = state->lencode[last.val + 1144 (BITS(last.bits + last.op) >> last.bits)]; 1145 if ((unsigned)(last.bits + here.bits) <= bits) break; 1146 PULLBYTE(); 1147 } 1148 DROPBITS(last.bits); 1149 state->back += last.bits; 1150 } 1151 DROPBITS(here.bits); 1152 state->back += here.bits; 1153 state->length = (unsigned)here.val; 1154 if ((int)(here.op) == 0) { 1155 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? 1156 "inflate: literal '%c'\n" : 1157 "inflate: literal 0x%02x\n", here.val)); 1158 state->mode = LIT; 1159 break; 1160 } 1161 if (here.op & 32) { 1162 Tracevv((stderr, "inflate: end of block\n")); 1163 state->back = -1; 1164 state->mode = TYPE; 1165 break; 1166 } 1167 if (here.op & 64) { 1168#ifdef SMALL 1169 strm->msg = "error"; 1170#else 1171 strm->msg = (char *)"invalid literal/length code"; 1172#endif 1173 state->mode = BAD; 1174 break; 1175 } 1176 state->extra = (unsigned)(here.op) & 15; 1177 state->mode = LENEXT; 1178 /* fallthrough */ 1179 case LENEXT: 1180 if (state->extra) { 1181 NEEDBITS(state->extra); 1182 state->length += BITS(state->extra); 1183 DROPBITS(state->extra); 1184 state->back += state->extra; 1185 } 1186 Tracevv((stderr, "inflate: length %u\n", state->length)); 1187 state->was = state->length; 1188 state->mode = DIST; 1189 /* fallthrough */ 1190 case DIST: 1191 for (;;) { 1192 here = state->distcode[BITS(state->distbits)]; 1193 if ((unsigned)(here.bits) <= bits) break; 1194 PULLBYTE(); 1195 } 1196 if ((here.op & 0xf0) == 0) { 1197 last = here; 1198 for (;;) { 1199 here = state->distcode[last.val + 1200 (BITS(last.bits + last.op) >> last.bits)]; 1201 if ((unsigned)(last.bits + here.bits) <= bits) break; 1202 PULLBYTE(); 1203 } 1204 DROPBITS(last.bits); 1205 state->back += last.bits; 1206 } 1207 DROPBITS(here.bits); 1208 state->back += here.bits; 1209 if (here.op & 64) { 1210#ifdef SMALL 1211 strm->msg = "error"; 1212#else 1213 strm->msg = (char *)"invalid distance code"; 1214#endif 1215 state->mode = BAD; 1216 break; 1217 } 1218 state->offset = (unsigned)here.val; 1219 state->extra = (unsigned)(here.op) & 15; 1220 state->mode = DISTEXT; 1221 /* fallthrough */ 1222 case DISTEXT: 1223 if (state->extra) { 1224 NEEDBITS(state->extra); 1225 state->offset += BITS(state->extra); 1226 DROPBITS(state->extra); 1227 state->back += state->extra; 1228 } 1229#ifdef INFLATE_STRICT 1230 if (state->offset > state->dmax) { 1231#ifdef SMALL 1232 strm->msg = "error"; 1233#else 1234 strm->msg = (char *)"invalid distance too far back"; 1235#endif 1236 state->mode = BAD; 1237 break; 1238 } 1239#endif 1240 Tracevv((stderr, "inflate: distance %u\n", state->offset)); 1241 state->mode = MATCH; 1242 /* fallthrough */ 1243 case MATCH: 1244 if (left == 0) goto inf_leave; 1245 copy = out - left; 1246 if (state->offset > copy) { /* copy from window */ 1247 copy = state->offset - copy; 1248 if (copy > state->whave) { 1249 if (state->sane) { 1250#ifdef SMALL 1251 strm->msg = "error"; 1252#else 1253 strm->msg = (char *)"invalid distance too far back"; 1254#endif 1255 state->mode = BAD; 1256 break; 1257 } 1258#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR 1259 Trace((stderr, "inflate.c too far\n")); 1260 copy -= state->whave; 1261 if (copy > state->length) copy = state->length; 1262 if (copy > left) copy = left; 1263 left -= copy; 1264 state->length -= copy; 1265 do { 1266 *put++ = 0; 1267 } while (--copy); 1268 if (state->length == 0) state->mode = LEN; 1269 break; 1270#endif 1271 } 1272 if (copy > state->wnext) { 1273 copy -= state->wnext; 1274 from = state->window + (state->wsize - copy); 1275 } 1276 else 1277 from = state->window + (state->wnext - copy); 1278 if (copy > state->length) copy = state->length; 1279 } 1280 else { /* copy from output */ 1281 from = put - state->offset; 1282 copy = state->length; 1283 } 1284 if (copy > left) copy = left; 1285 left -= copy; 1286 state->length -= copy; 1287 do { 1288 *put++ = *from++; 1289 } while (--copy); 1290 if (state->length == 0) state->mode = LEN; 1291 break; 1292 case LIT: 1293 if (left == 0) goto inf_leave; 1294 *put++ = (unsigned char)(state->length); 1295 left--; 1296 state->mode = LEN; 1297 break; 1298 case CHECK: 1299 if (state->wrap) { 1300 NEEDBITS(32); 1301 out -= left; 1302 strm->total_out += out; 1303 state->total += out; 1304 if ((state->wrap & 4) && out) 1305 strm->adler = state->check = 1306 UPDATE_CHECK(state->check, put - out, out); 1307 out = left; 1308 if ((state->wrap & 4) && ( 1309#ifdef GUNZIP 1310 state->flags ? hold : 1311#endif 1312 ZSWAP32(hold)) != state->check) { 1313#ifdef SMALL 1314 strm->msg = "error"; 1315#else 1316 strm->msg = (char *)"incorrect data check"; 1317#endif 1318 state->mode = BAD; 1319 break; 1320 } 1321 INITBITS(); 1322 Tracev((stderr, "inflate: check matches trailer\n")); 1323 } 1324#ifdef GUNZIP 1325 state->mode = LENGTH; 1326 /* fallthrough */ 1327 case LENGTH: 1328 if (state->wrap && state->flags) { 1329 NEEDBITS(32); 1330 if ((state->wrap & 4) && hold != (state->total & 0xffffffff)) { 1331#ifdef SMALL 1332 strm->msg = "error"; 1333#else 1334 strm->msg = (char *)"incorrect length check"; 1335#endif 1336 state->mode = BAD; 1337 break; 1338 } 1339 INITBITS(); 1340 Tracev((stderr, "inflate: length matches trailer\n")); 1341 } 1342#endif 1343 state->mode = DONE; 1344 /* fallthrough */ 1345 case DONE: 1346 ret = Z_STREAM_END; 1347 goto inf_leave; 1348 case BAD: 1349 ret = Z_DATA_ERROR; 1350 goto inf_leave; 1351 case MEM: 1352 return Z_MEM_ERROR; 1353 case SYNC: 1354 /* fallthrough */ 1355 default: 1356 return Z_STREAM_ERROR; 1357 } 1358 1359 /* 1360 Return from inflate(), updating the total counts and the check value. 1361 If there was no progress during the inflate() call, return a buffer 1362 error. Call updatewindow() to create and/or update the window state. 1363 Note: a memory error from inflate() is non-recoverable. 1364 */ 1365 inf_leave: 1366 RESTORE(); 1367 if (state->wsize || (out != strm->avail_out && state->mode < BAD && 1368 (state->mode < CHECK || flush != Z_FINISH))) 1369 if (updatewindow(strm, strm->next_out, out - strm->avail_out)) { 1370 state->mode = MEM; 1371 return Z_MEM_ERROR; 1372 } 1373 in -= strm->avail_in; 1374 out -= strm->avail_out; 1375 strm->total_in += in; 1376 strm->total_out += out; 1377 state->total += out; 1378 if ((state->wrap & 4) && out) 1379 strm->adler = state->check = 1380 UPDATE_CHECK(state->check, strm->next_out - out, out); 1381 strm->data_type = (int)state->bits + (state->last ? 64 : 0) + 1382 (state->mode == TYPE ? 128 : 0) + 1383 (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); 1384 if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) 1385 ret = Z_BUF_ERROR; 1386 return ret; 1387} 1388 1389int ZEXPORT inflateEnd(strm) 1390z_streamp strm; 1391{ 1392 struct inflate_state FAR *state; 1393 if (inflateStateCheck(strm)) 1394 return Z_STREAM_ERROR; 1395 state = (struct inflate_state FAR *)strm->state; 1396 if (state->window != Z_NULL) ZFREE(strm, state->window); 1397 ZFREE(strm, strm->state); 1398 strm->state = Z_NULL; 1399 Tracev((stderr, "inflate: end\n")); 1400 return Z_OK; 1401} 1402 1403int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength) 1404z_streamp strm; 1405Bytef *dictionary; 1406uInt *dictLength; 1407{ 1408 struct inflate_state FAR *state; 1409 1410 /* check state */ 1411 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1412 state = (struct inflate_state FAR *)strm->state; 1413 1414 /* copy dictionary */ 1415 if (state->whave && dictionary != Z_NULL) { 1416 zmemcpy(dictionary, state->window + state->wnext, 1417 state->whave - state->wnext); 1418 zmemcpy(dictionary + state->whave - state->wnext, 1419 state->window, state->wnext); 1420 } 1421 if (dictLength != Z_NULL) 1422 *dictLength = state->whave; 1423 return Z_OK; 1424} 1425 1426int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) 1427z_streamp strm; 1428const Bytef *dictionary; 1429uInt dictLength; 1430{ 1431 struct inflate_state FAR *state; 1432 unsigned long dictid; 1433 int ret; 1434 1435 /* check state */ 1436 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1437 state = (struct inflate_state FAR *)strm->state; 1438 if (state->wrap != 0 && state->mode != DICT) 1439 return Z_STREAM_ERROR; 1440 1441 /* check for correct dictionary identifier */ 1442 if (state->mode == DICT) { 1443 dictid = adler32(0L, Z_NULL, 0); 1444 dictid = adler32(dictid, dictionary, dictLength); 1445 if (dictid != state->check) 1446 return Z_DATA_ERROR; 1447 } 1448 1449 /* copy dictionary to window using updatewindow(), which will amend the 1450 existing dictionary if appropriate */ 1451 ret = updatewindow(strm, dictionary + dictLength, dictLength); 1452 if (ret) { 1453 state->mode = MEM; 1454 return Z_MEM_ERROR; 1455 } 1456 state->havedict = 1; 1457 Tracev((stderr, "inflate: dictionary set\n")); 1458 return Z_OK; 1459} 1460 1461int ZEXPORT inflateGetHeader(strm, head) 1462z_streamp strm; 1463gz_headerp head; 1464{ 1465 struct inflate_state FAR *state; 1466 1467 /* check state */ 1468 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1469 state = (struct inflate_state FAR *)strm->state; 1470 if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; 1471 1472 /* save header structure */ 1473 state->head = head; 1474 head->done = 0; 1475 return Z_OK; 1476} 1477 1478/* 1479 Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found 1480 or when out of input. When called, *have is the number of pattern bytes 1481 found in order so far, in 0..3. On return *have is updated to the new 1482 state. If on return *have equals four, then the pattern was found and the 1483 return value is how many bytes were read including the last byte of the 1484 pattern. If *have is less than four, then the pattern has not been found 1485 yet and the return value is len. In the latter case, syncsearch() can be 1486 called again with more data and the *have state. *have is initialized to 1487 zero for the first call. 1488 */ 1489local unsigned syncsearch(have, buf, len) 1490unsigned FAR *have; 1491const unsigned char FAR *buf; 1492unsigned len; 1493{ 1494 unsigned got; 1495 unsigned next; 1496 1497 got = *have; 1498 next = 0; 1499 while (next < len && got < 4) { 1500 if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) 1501 got++; 1502 else if (buf[next]) 1503 got = 0; 1504 else 1505 got = 4 - got; 1506 next++; 1507 } 1508 *have = got; 1509 return next; 1510} 1511 1512int ZEXPORT inflateSync(strm) 1513z_streamp strm; 1514{ 1515 unsigned len; /* number of bytes to look at or looked at */ 1516 int flags; /* temporary to save header status */ 1517 unsigned long in, out; /* temporary to save total_in and total_out */ 1518 unsigned char buf[4]; /* to restore bit buffer to byte string */ 1519 struct inflate_state FAR *state; 1520 1521 /* check parameters */ 1522 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1523 state = (struct inflate_state FAR *)strm->state; 1524 if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; 1525 1526 /* if first time, start search in bit buffer */ 1527 if (state->mode != SYNC) { 1528 state->mode = SYNC; 1529 state->hold <<= state->bits & 7; 1530 state->bits -= state->bits & 7; 1531 len = 0; 1532 while (state->bits >= 8) { 1533 buf[len++] = (unsigned char)(state->hold); 1534 state->hold >>= 8; 1535 state->bits -= 8; 1536 } 1537 state->have = 0; 1538 syncsearch(&(state->have), buf, len); 1539 } 1540 1541 /* search available input */ 1542 len = syncsearch(&(state->have), strm->next_in, strm->avail_in); 1543 strm->avail_in -= len; 1544 strm->next_in += len; 1545 strm->total_in += len; 1546 1547 /* return no joy or set up to restart inflate() on a new block */ 1548 if (state->have != 4) return Z_DATA_ERROR; 1549 if (state->flags == -1) 1550 state->wrap = 0; /* if no header yet, treat as raw */ 1551 else 1552 state->wrap &= ~4; /* no point in computing a check value now */ 1553 flags = state->flags; 1554 in = strm->total_in; out = strm->total_out; 1555 inflateReset(strm); 1556 strm->total_in = in; strm->total_out = out; 1557 state->flags = flags; 1558 state->mode = TYPE; 1559 return Z_OK; 1560} 1561 1562/* 1563 Returns true if inflate is currently at the end of a block generated by 1564 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP 1565 implementation to provide an additional safety check. PPP uses 1566 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored 1567 block. When decompressing, PPP checks that at the end of input packet, 1568 inflate is waiting for these length bytes. 1569 */ 1570int ZEXPORT inflateSyncPoint(strm) 1571z_streamp strm; 1572{ 1573 struct inflate_state FAR *state; 1574 1575 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1576 state = (struct inflate_state FAR *)strm->state; 1577 return state->mode == STORED && state->bits == 0; 1578} 1579 1580int ZEXPORT inflateCopy(dest, source) 1581z_streamp dest; 1582z_streamp source; 1583{ 1584 struct inflate_state FAR *state; 1585 struct inflate_state FAR *copy; 1586 unsigned char FAR *window; 1587 unsigned wsize; 1588 1589 /* check input */ 1590 if (inflateStateCheck(source) || dest == Z_NULL) 1591 return Z_STREAM_ERROR; 1592 state = (struct inflate_state FAR *)source->state; 1593 1594 /* allocate space */ 1595 copy = (struct inflate_state FAR *) 1596 ZALLOC(source, 1, sizeof(struct inflate_state)); 1597 if (copy == Z_NULL) return Z_MEM_ERROR; 1598 window = Z_NULL; 1599 if (state->window != Z_NULL) { 1600 window = (unsigned char FAR *) 1601 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); 1602 if (window == Z_NULL) { 1603 ZFREE(source, copy); 1604 return Z_MEM_ERROR; 1605 } 1606 } 1607 1608 /* copy state */ 1609 zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); 1610 zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state)); 1611 copy->strm = dest; 1612 if (state->lencode >= state->codes && 1613 state->lencode <= state->codes + ENOUGH - 1) { 1614 copy->lencode = copy->codes + (state->lencode - state->codes); 1615 copy->distcode = copy->codes + (state->distcode - state->codes); 1616 } 1617 copy->next = copy->codes + (state->next - state->codes); 1618 if (window != Z_NULL) { 1619 wsize = 1U << state->wbits; 1620 zmemcpy(window, state->window, wsize); 1621 } 1622 copy->window = window; 1623 dest->state = (struct internal_state FAR *)copy; 1624 return Z_OK; 1625} 1626 1627int ZEXPORT inflateUndermine(strm, subvert) 1628z_streamp strm; 1629int subvert; 1630{ 1631 struct inflate_state FAR *state; 1632 1633 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1634 state = (struct inflate_state FAR *)strm->state; 1635#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR 1636 state->sane = !subvert; 1637 return Z_OK; 1638#else 1639 (void)subvert; 1640 state->sane = 1; 1641 return Z_DATA_ERROR; 1642#endif 1643} 1644 1645int ZEXPORT inflateValidate(strm, check) 1646z_streamp strm; 1647int check; 1648{ 1649 struct inflate_state FAR *state; 1650 1651 if (inflateStateCheck(strm)) return Z_STREAM_ERROR; 1652 state = (struct inflate_state FAR *)strm->state; 1653 if (check && state->wrap) 1654 state->wrap |= 4; 1655 else 1656 state->wrap &= ~4; 1657 return Z_OK; 1658} 1659 1660long ZEXPORT inflateMark(strm) 1661z_streamp strm; 1662{ 1663 struct inflate_state FAR *state; 1664 1665 if (inflateStateCheck(strm)) 1666 return -(1L << 16); 1667 state = (struct inflate_state FAR *)strm->state; 1668 return (long)(((unsigned long)((long)state->back)) << 16) + 1669 (state->mode == COPY ? state->length : 1670 (state->mode == MATCH ? state->was - state->length : 0)); 1671} 1672 1673unsigned long ZEXPORT inflateCodesUsed(strm) 1674z_streamp strm; 1675{ 1676 struct inflate_state FAR *state; 1677 if (inflateStateCheck(strm)) return (unsigned long)-1; 1678 state = (struct inflate_state FAR *)strm->state; 1679 return (unsigned long)(state->next - state->codes); 1680} 1681