inflate.c

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