zlib/inflate.c

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