support/inflate.c

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