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->max_window_dist = 0;
 118         state->dist_window_tail = 0;
 119         state->dist_window = (unsigned short*)realloc(state->dist_window, state->dmax * sizeof(unsigned short));
 120         memset(state->dist_window, 0, state->dmax * sizeof(unsigned short));
 121     state->head = Z_NULL;
 122     state->wsize = 0;
 123     state->whave = 0;
 124     state->write = 0;
 125     state->hold = 0;
 126     state->bits = 0;
 127     state->lencode = state->distcode = state->next = state->codes;
 128     Tracev((stderr, "inflate: reset\n"));
 129     return Z_OK;
 130 }
 131
 132 int ZEXPORT inflatePrime(strm, bits, value)
 133 z_streamp strm;
 134 int bits;
 135 int value;
 136 {
 137     struct inflate_state FAR *state;
 138
 139     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
 140     state = (struct inflate_state FAR *)strm->state;
 141     if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
 142     value &= (1L << bits) - 1;
 143     state->hold += value << state->bits;
 144     state->bits += bits;
 145     return Z_OK;
 146 }
 147
 148 int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
 149 z_streamp strm;
 150 int windowBits;
 151 const char *version;
 152 int stream_size;
 153 {
 154     struct inflate_state FAR *state;
 155
 156     if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
 157         stream_size != (int)(sizeof(z_stream)))
 158         return Z_VERSION_ERROR;
 159     if (strm == Z_NULL) return Z_STREAM_ERROR;
 160     strm->msg = Z_NULL;                 /* in case we return an error */
 161     if (strm->zalloc == (alloc_func)0) {
 162         strm->zalloc = zcalloc;
 163         strm->opaque = (voidpf)0;
 164     }
 165     if (strm->zfree == (free_func)0) strm->zfree = zcfree;
 166     state = (struct inflate_state FAR *)
 167             ZALLOC(strm, 1, sizeof(struct inflate_state));
 168     if (state == Z_NULL) return Z_MEM_ERROR;
 169     Tracev((stderr, "inflate: allocated\n"));
 170     strm->state = (struct internal_state FAR *)state;
 171     if (windowBits < 0) {
 172         state->wrap = 0;
 173         windowBits = -windowBits;
 174     }
 175     else {
 176         state->wrap = (windowBits >> 4) + 1;
 177 #ifdef GUNZIP
 178         if (windowBits < 48) windowBits &= 15;
 179 #endif
 180     }
 181     if (windowBits < 8 || windowBits > 15) {
 182         ZFREE(strm, state);
 183         strm->state = Z_NULL;
 184         return Z_STREAM_ERROR;
 185     }
 186     state->wbits = (unsigned)windowBits;
 187     state->window = Z_NULL;
 188         state->dist_window = NULL;
 189     return inflateReset(strm);
 190 }
 191
 192 int ZEXPORT inflateInit_(strm, version, stream_size)
 193 z_streamp strm;
 194 const char *version;
 195 int stream_size;
 196 {
 197     return inflateInit2_(strm, DEF_WBITS, version, stream_size);
 198 }
 199
 200 /*
 201    Return state with length and distance decoding tables and index sizes set to
 202    fixed code decoding.  Normally this returns fixed tables from inffixed.h.
 203    If BUILDFIXED is defined, then instead this routine builds the tables the
 204    first time it's called, and returns those tables the first time and
 205    thereafter.  This reduces the size of the code by about 2K bytes, in
 206    exchange for a little execution time.  However, BUILDFIXED should not be
 207    used for threaded applications, since the rewriting of the tables and virgin
 208    may not be thread-safe.
 209  */
 210 local void fixedtables(state)
 211 struct inflate_state FAR *state;
 212 {
 213 #ifdef BUILDFIXED
 214     static int virgin = 1;
 215     static code *lenfix, *distfix;
 216     static code fixed[544];
 217
 218     /* build fixed huffman tables if first call (may not be thread safe) */
 219     if (virgin) {
 220         unsigned sym, bits;
 221         static code *next;
 222
 223         /* literal/length table */
 224         sym = 0;
 225         while (sym < 144) state->lens[sym++] = 8;
 226         while (sym < 256) state->lens[sym++] = 9;
 227         while (sym < 280) state->lens[sym++] = 7;
 228         while (sym < 288) state->lens[sym++] = 8;
 229         next = fixed;
 230         lenfix = next;
 231         bits = 9;
 232         inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
 233
 234         /* distance table */
 235         sym = 0;
 236         while (sym < 32) state->lens[sym++] = 5;
 237         distfix = next;
 238         bits = 5;
 239         inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
 240
 241         /* do this just once */
 242         virgin = 0;
 243     }
 244 #else /* !BUILDFIXED */
 245 #   include "inffixed.h"
 246 #endif /* BUILDFIXED */
 247     state->lencode = lenfix;
 248     state->lenbits = 9;
 249     state->distcode = distfix;
 250     state->distbits = 5;
 251 }
 252
 253 #ifdef MAKEFIXED
 254 #include <stdio.h>
 255
 256 /*
 257    Write out the inffixed.h that is #include'd above.  Defining MAKEFIXED also
 258    defines BUILDFIXED, so the tables are built on the fly.  makefixed() writes
 259    those tables to stdout, which would be piped to inffixed.h.  A small program
 260    can simply call makefixed to do this:
 261
 262     void makefixed(void);
 263
 264     int main(void)
 265     {
 266         makefixed();
 267         return 0;
 268     }
 269
 270    Then that can be linked with zlib built with MAKEFIXED defined and run:
 271
 272     a.out > inffixed.h
 273  */
 274 void makefixed()
 275 {
 276     unsigned low, size;
 277     struct inflate_state state;
 278
 279     fixedtables(&state);
 280     puts("    /* inffixed.h -- table for decoding fixed codes");
 281     puts("     * Generated automatically by makefixed().");
 282     puts("     */");
 283     puts("");
 284     puts("    /* WARNING: this file should *not* be used by applications.");
 285     puts("       It is part of the implementation of this library and is");
 286     puts("       subject to change. Applications should only use zlib.h.");
 287     puts("     */");
 288     puts("");
 289     size = 1U << 9;
 290     printf("    static const code lenfix[%u] = {", size);
 291     low = 0;
 292     for (;;) {
 293         if ((low % 7) == 0) printf("\n        ");
 294         printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
 295                state.lencode[low].val);
 296         if (++low == size) break;
 297         putchar(',');
 298     }
 299     puts("\n    };");
 300     size = 1U << 5;
 301     printf("\n    static const code distfix[%u] = {", size);
 302     low = 0;
 303     for (;;) {
 304         if ((low % 6) == 0) printf("\n        ");
 305         printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
 306                state.distcode[low].val);
 307         if (++low == size) break;
 308         putchar(',');
 309     }
 310     puts("\n    };");
 311 }
 312 #endif /* MAKEFIXED */
 313
 314 /*
 315    Update the window with the last wsize (normally 32K) bytes written before
 316    returning.  If window does not exist yet, create it.  This is only called
 317    when a window is already in use, or when output has been written during this
 318    inflate call, but the end of the deflate stream has not been reached yet.
 319    It is also called to create a window for dictionary data when a dictionary
 320    is loaded.
 321
 322    Providing output buffers larger than 32K to inflate() should provide a speed
 323    advantage, since only the last 32K of output is copied to the sliding window
 324    upon return from inflate(), and since all distances after the first 32K of
 325    output will fall in the output data, making match copies simpler and faster.
 326    The advantage may be dependent on the size of the processor's data caches.
 327  */
 328 local int updatewindow(strm, out)
 329 z_streamp strm;
 330 unsigned out;
 331 {
 332     struct inflate_state FAR *state;
 333     unsigned copy, dist;
 334
 335     state = (struct inflate_state FAR *)strm->state;
 336
 337     /* if it hasn't been done already, allocate space for the window */
 338     if (state->window == Z_NULL) {
 339         state->window = (unsigned char FAR *)
 340                         ZALLOC(strm, 1U << state->wbits,
 341                                sizeof(unsigned char));
 342         if (state->window == Z_NULL) return 1;
 343     }
 344
 345     /* if window not in use yet, initialize */
 346     if (state->wsize == 0) {
 347         state->wsize = 1U << state->wbits;
 348         state->write = 0;
 349         state->whave = 0;
 350     }
 351
 352     /* copy state->wsize or less output bytes into the circular window */
 353     copy = out - strm->avail_out;
 354     if (copy >= state->wsize) {
 355         zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
 356         state->write = 0;
 357         state->whave = state->wsize;
 358     }
 359     else {
 360         dist = state->wsize - state->write;
 361         if (dist > copy) dist = copy;
 362         zmemcpy(state->window + state->write, strm->next_out - copy, dist);
 363         copy -= dist;
 364         if (copy) {
 365             zmemcpy(state->window, strm->next_out - copy, copy);
 366             state->write = copy;
 367             state->whave = state->wsize;
 368         }
 369         else {
 370             state->write += dist;
 371             if (state->write == state->wsize) state->write = 0;
 372             if (state->whave < state->wsize) state->whave += dist;
 373         }
 374     }
 375     return 0;
 376 }
 377
 378 /* Macros for inflate(): */
 379
 380 /* check function to use adler32() for zlib or crc32() for gzip */
 381 #ifdef GUNZIP
 382 #  define UPDATE(check, buf, len) \
 383     (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
 384 #else
 385 #  define UPDATE(check, buf, len) adler32(check, buf, len)
 386 #endif
 387
 388 /* check macros for header crc */
 389 #ifdef GUNZIP
 390 #  define CRC2(check, word) \
 391     do { \
 392         hbuf[0] = (unsigned char)(word); \
 393         hbuf[1] = (unsigned char)((word) >> 8); \
 394         check = crc32(check, hbuf, 2); \
 395     } while (0)
 396
 397 #  define CRC4(check, word) \
 398     do { \
 399         hbuf[0] = (unsigned char)(word); \
 400         hbuf[1] = (unsigned char)((word) >> 8); \
 401         hbuf[2] = (unsigned char)((word) >> 16); \
 402         hbuf[3] = (unsigned char)((word) >> 24); \
 403         check = crc32(check, hbuf, 4); \
 404     } while (0)
 405 #endif
 406
 407 /* Load registers with state in inflate() for speed */
 408 #define LOAD() \
 409     do { \
 410         put = strm->next_out; \
 411         left = strm->avail_out; \
 412         next = strm->next_in; \
 413         have = strm->avail_in; \
 414         hold = state->hold; \
 415         bits = state->bits; \
 416     } while (0)
 417
 418 /* Restore state from registers in inflate() */
 419 #define RESTORE() \
 420     do { \
 421         strm->next_out = put; \
 422         strm->avail_out = left; \
 423         strm->next_in = next; \
 424         strm->avail_in = have; \
 425         state->hold = hold; \
 426         state->bits = bits; \
 427     } while (0)
 428
 429 /* Clear the input bit accumulator */
 430 #define INITBITS() \
 431     do { \
 432         hold = 0; \
 433         bits = 0; \
 434     } while (0)
 435
 436 /* Get a byte of input into the bit accumulator, or return from inflate()
 437    if there is no input available. */
 438 #define PULLBYTE() \
 439     do { \
 440         if (have == 0) goto inf_leave; \
 441         have--; \
 442         hold += (unsigned long)(*next++) << bits; \
 443         bits += 8; \
 444     } while (0)
 445
 446 /* Assure that there are at least n bits in the bit accumulator.  If there is
 447    not enough available input to do that, then return from inflate(). */
 448 #define NEEDBITS(n) \
 449     do { \
 450         while (bits < (unsigned)(n)) \
 451             PULLBYTE(); \
 452     } while (0)
 453
 454 /* Return the low n bits of the bit accumulator (n < 16) */
 455 #define BITS(n) \
 456     ((unsigned)hold & ((1U << (n)) - 1))
 457
 458 /* Remove n bits from the bit accumulator */
 459 #define DROPBITS(n) \
 460     do { \
 461         hold >>= (n); \
 462         bits -= (unsigned)(n); \
 463     } while (0)
 464
 465 /* Remove zero to seven bits as needed to go to a byte boundary */
 466 #define BYTEBITS() \
 467     do { \
 468         hold >>= bits & 7; \
 469         bits -= bits & 7; \
 470     } while (0)
 471
 472 /* Reverse the bytes in a 32-bit value */
 473 #define REVERSE(q) \
 474     ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
 475      (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
 476
 477 /*
 478    inflate() uses a state machine to process as much input data and generate as
 479    much output data as possible before returning.  The state machine is
 480    structured roughly as follows:
 481
 482     for (;;) switch (state) {
 483     ...
 484     case STATEn:
 485         if (not enough input data or output space to make progress)
 486             return;
 487         ... make progress ...
 488         state = STATEm;
 489         break;
 490     ...
 491     }
 492
 493    so when inflate() is called again, the same case is attempted again, and
 494    if the appropriate resources are provided, the machine proceeds to the
 495    next state.  The NEEDBITS() macro is usually the way the state evaluates
 496    whether it can proceed or should return.  NEEDBITS() does the return if
 497    the requested bits are not available.  The typical use of the BITS macros
 498    is:
 499
 500         NEEDBITS(n);
 501         ... do something with BITS(n) ...
 502         DROPBITS(n);
 503
 504    where NEEDBITS(n) either returns from inflate() if there isn't enough
 505    input left to load n bits into the accumulator, or it continues.  BITS(n)
 506    gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
 507    the low n bits off the accumulator.  INITBITS() clears the accumulator
 508    and sets the number of available bits to zero.  BYTEBITS() discards just
 509    enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
 510    and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
 511
 512    NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
 513    if there is no input available.  The decoding of variable length codes uses
 514    PULLBYTE() directly in order to pull just enough bytes to decode the next
 515    code, and no more.
 516
 517    Some states loop until they get enough input, making sure that enough
 518    state information is maintained to continue the loop where it left off
 519    if NEEDBITS() returns in the loop.  For example, want, need, and keep
 520    would all have to actually be part of the saved state in case NEEDBITS()
 521    returns:
 522
 523     case STATEw:
 524         while (want < need) {
 525             NEEDBITS(n);
 526             keep[want++] = BITS(n);
 527             DROPBITS(n);
 528         }
 529         state = STATEx;
 530     case STATEx:
 531
 532    As shown above, if the next state is also the next case, then the break
 533    is omitted.
 534
 535    A state may also return if there is not enough output space available to
 536    complete that state.  Those states are copying stored data, writing a
 537    literal byte, and copying a matching string.
 538
 539    When returning, a "goto inf_leave" is used to update the total counters,
 540    update the check value, and determine whether any progress has been made
 541    during that inflate() call in order to return the proper return code.
 542    Progress is defined as a change in either strm->avail_in or strm->avail_out.
 543    When there is a window, goto inf_leave will update the window with the last
 544    output written.  If a goto inf_leave occurs in the middle of decompression
 545    and there is no window currently, goto inf_leave will create one and copy
 546    output to the window for the next call of inflate().
 547
 548    In this implementation, the flush parameter of inflate() only affects the
 549    return code (per zlib.h).  inflate() always writes as much as possible to
 550    strm->next_out, given the space available and the provided input--the effect
 551    documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
 552    the allocation of and copying into a sliding window until necessary, which
 553    provides the effect documented in zlib.h for Z_FINISH when the entire input
 554    stream available.  So the only thing the flush parameter actually does is:
 555    when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
 556    will return Z_BUF_ERROR if it has not reached the end of the stream.
 557  */
 558
 559 int ZEXPORT inflate(strm, flush)
 560 z_streamp strm;
 561 int flush;
 562 {
 563     struct inflate_state FAR *state;
 564     unsigned char FAR *next;    /* next input */
 565     unsigned char FAR *put;     /* next output */
 566     unsigned have, left;        /* available input and output */
 567     unsigned long hold;         /* bit buffer */
 568     unsigned bits;              /* bits in bit buffer */
 569     unsigned in, out;           /* save starting available input and output */
 570     unsigned copy;              /* number of stored or match bytes to copy */
 571     unsigned char FAR *from;    /* where to copy match bytes from */
 572     code this;                  /* current decoding table entry */
 573     code last;                  /* parent table entry */
 574     unsigned len;               /* length to copy for repeats, bits to drop */
 575     int ret;                    /* return code */
 576 #ifdef GUNZIP
 577     unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
 578 #endif
 579     static const unsigned short order[19] = /* permutation of code lengths */
 580         {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
 581
 582     if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
 583         (strm->next_in == Z_NULL && strm->avail_in != 0))
 584         return Z_STREAM_ERROR;
 585
 586     state = (struct inflate_state FAR *)strm->state;
 587     if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
 588     LOAD();
 589     in = have;
 590     out = left;
 591     ret = Z_OK;
 592     for (;;)
 593         switch (state->mode) {
 594         case HEAD:
 595             if (state->wrap == 0) {
 596                 state->mode = TYPEDO;
 597                 break;
 598             }
 599             NEEDBITS(16);
 600 #ifdef GUNZIP
 601             if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
 602                 state->check = crc32(0L, Z_NULL, 0);
 603                 CRC2(state->check, hold);
 604                 INITBITS();
 605                 state->mode = FLAGS;
 606                 break;
 607             }
 608             state->flags = 0;           /* expect zlib header */
 609             if (state->head != Z_NULL)
 610                 state->head->done = -1;
 611             if (!(state->wrap & 1) ||   /* check if zlib header allowed */
 612 #else
 613             if (
 614 #endif
 615                 ((BITS(8) << 8) + (hold >> 8)) % 31) {
 616                 strm->msg = (char *)"incorrect header check";
 617                 state->mode = BAD;
 618                 break;
 619             }
 620             if (BITS(4) != Z_DEFLATED) {
 621                 strm->msg = (char *)"unknown compression method";
 622                 state->mode = BAD;
 623                 break;
 624             }
 625             DROPBITS(4);
 626             len = BITS(4) + 8;
 627             if (len > state->wbits) {
 628                 strm->msg = (char *)"invalid window size";
 629                 state->mode = BAD;
 630                 break;
 631             }
 632             state->dmax = 1U << len;
 633                         state->max_window_dist = 0;
 634                         state->dist_window_tail = 0;
 635                         state->dist_window = (unsigned short*)realloc(state->dist_window, state->dmax * sizeof(unsigned short));
 636                         memset(state->dist_window, 0, state->dmax * sizeof(unsigned short));
 637             Tracev((stderr, "inflate:   zlib header ok\n"));
 638             strm->adler = state->check = adler32(0L, Z_NULL, 0);
 639             state->mode = hold & 0x200 ? DICTID : TYPE;
 640             INITBITS();
 641             break;
 642 #ifdef GUNZIP
 643         case FLAGS:
 644             NEEDBITS(16);
 645             state->flags = (int)(hold);
 646             if ((state->flags & 0xff) != Z_DEFLATED) {
 647                 strm->msg = (char *)"unknown compression method";
 648                 state->mode = BAD;
 649                 break;
 650             }
 651             if (state->flags & 0xe000) {
 652                 strm->msg = (char *)"unknown header flags set";
 653                 state->mode = BAD;
 654                 break;
 655             }
 656             if (state->head != Z_NULL)
 657                 state->head->text = (int)((hold >> 8) & 1);
 658             if (state->flags & 0x0200) CRC2(state->check, hold);
 659             INITBITS();
 660             state->mode = TIME;
 661         case TIME:
 662             NEEDBITS(32);
 663             if (state->head != Z_NULL)
 664                 state->head->time = hold;
 665             if (state->flags & 0x0200) CRC4(state->check, hold);
 666             INITBITS();
 667             state->mode = OS;
 668         case OS:
 669             NEEDBITS(16);
 670             if (state->head != Z_NULL) {
 671                 state->head->xflags = (int)(hold & 0xff);
 672                 state->head->os = (int)(hold >> 8);
 673             }
 674             if (state->flags & 0x0200) CRC2(state->check, hold);
 675             INITBITS();
 676             state->mode = EXLEN;
 677         case EXLEN:
 678             if (state->flags & 0x0400) {
 679                 NEEDBITS(16);
 680                 state->length = (unsigned)(hold);
 681                 if (state->head != Z_NULL)
 682                     state->head->extra_len = (unsigned)hold;
 683                 if (state->flags & 0x0200) CRC2(state->check, hold);
 684                 INITBITS();
 685             }
 686             else if (state->head != Z_NULL)
 687                 state->head->extra = Z_NULL;
 688             state->mode = EXTRA;
 689         case EXTRA:
 690             if (state->flags & 0x0400) {
 691                 copy = state->length;
 692                 if (copy > have) copy = have;
 693                 if (copy) {
 694                     if (state->head != Z_NULL &&
 695                         state->head->extra != Z_NULL) {
 696                         len = state->head->extra_len - state->length;
 697                         zmemcpy(state->head->extra + len, next,
 698                                 len + copy > state->head->extra_max ?
 699                                 state->head->extra_max - len : copy);
 700                     }
 701                     if (state->flags & 0x0200)
 702                         state->check = crc32(state->check, next, copy);
 703                     have -= copy;
 704                     next += copy;
 705                     state->length -= copy;
 706                 }
 707                 if (state->length) goto inf_leave;
 708             }
 709             state->length = 0;
 710             state->mode = NAME;
 711         case NAME:
 712             if (state->flags & 0x0800) {
 713                 if (have == 0) goto inf_leave;
 714                 copy = 0;
 715                 do {
 716                     len = (unsigned)(next[copy++]);
 717                     if (state->head != Z_NULL &&
 718                             state->head->name != Z_NULL &&
 719                             state->length < state->head->name_max)
 720                         state->head->name[state->length++] = len;
 721                 } while (len && copy < have);
 722                 if (state->flags & 0x0200)
 723                     state->check = crc32(state->check, next, copy);
 724                 have -= copy;
 725                 next += copy;
 726                 if (len) goto inf_leave;
 727             }
 728             else if (state->head != Z_NULL)
 729                 state->head->name = Z_NULL;
 730             state->length = 0;
 731             state->mode = COMMENT;
 732         case COMMENT:
 733             if (state->flags & 0x1000) {
 734                 if (have == 0) goto inf_leave;
 735                 copy = 0;
 736                 do {
 737                     len = (unsigned)(next[copy++]);
 738                     if (state->head != Z_NULL &&
 739                             state->head->comment != Z_NULL &&
 740                             state->length < state->head->comm_max)
 741                         state->head->comment[state->length++] = len;
 742                 } while (len && copy < have);
 743                 if (state->flags & 0x0200)
 744                     state->check = crc32(state->check, next, copy);
 745                 have -= copy;
 746                 next += copy;
 747                 if (len) goto inf_leave;
 748             }
 749             else if (state->head != Z_NULL)
 750                 state->head->comment = Z_NULL;
 751             state->mode = HCRC;
 752         case HCRC:
 753             if (state->flags & 0x0200) {
 754                 NEEDBITS(16);
 755                 if (hold != (state->check & 0xffff)) {
 756                     strm->msg = (char *)"header crc mismatch";
 757                     state->mode = BAD;
 758                     break;
 759                 }
 760                 INITBITS();
 761             }
 762             if (state->head != Z_NULL) {
 763                 state->head->hcrc = (int)((state->flags >> 9) & 1);
 764                 state->head->done = 1;
 765             }
 766             strm->adler = state->check = crc32(0L, Z_NULL, 0);
 767             state->mode = TYPE;
 768             break;
 769 #endif
 770         case DICTID:
 771             NEEDBITS(32);
 772             strm->adler = state->check = REVERSE(hold);
 773             INITBITS();
 774             state->mode = DICT;
 775         case DICT:
 776             if (state->havedict == 0) {
 777                 RESTORE();
 778                 return Z_NEED_DICT;
 779             }
 780             strm->adler = state->check = adler32(0L, Z_NULL, 0);
 781             state->mode = TYPE;
 782         case TYPE:
 783             if (flush == Z_BLOCK) goto inf_leave;
 784         case TYPEDO:
 785             if (state->last) {
 786                 BYTEBITS();
 787                 state->mode = CHECK;
 788                 break;
 789             }
 790             NEEDBITS(3);
 791             state->last = BITS(1);
 792             DROPBITS(1);
 793             switch (BITS(2)) {
 794             case 0:                             /* stored block */
 795                 Tracev((stderr, "inflate:     stored block%s\n",
 796                         state->last ? " (last)" : ""));
 797                 state->mode = STORED;
 798                 break;
 799             case 1:                             /* fixed block */
 800                 fixedtables(state);
 801                 Tracev((stderr, "inflate:     fixed codes block%s\n",
 802                         state->last ? " (last)" : ""));
 803                 state->mode = LEN;              /* decode codes */
 804                 break;
 805             case 2:                             /* dynamic block */
 806                 Tracev((stderr, "inflate:     dynamic codes block%s\n",
 807                         state->last ? " (last)" : ""));
 808                 state->mode = TABLE;
 809                 break;
 810             case 3:
 811                 strm->msg = (char *)"invalid block type";
 812                 state->mode = BAD;
 813             }
 814             DROPBITS(2);
 815             break;
 816         case STORED:
 817             BYTEBITS();                         /* go to byte boundary */
 818             NEEDBITS(32);
 819             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
 820                 strm->msg = (char *)"invalid stored block lengths";
 821                 state->mode = BAD;
 822                 break;
 823             }
 824             state->length = (unsigned)hold & 0xffff;
 825             Tracev((stderr, "inflate:       stored length %u\n",
 826                     state->length));
 827             INITBITS();
 828             state->mode = COPY;
 829         case COPY:
 830             copy = state->length;
 831             if (copy) {
 832                 if (copy > have) copy = have;
 833                 if (copy > left) copy = left;
 834                 if (copy == 0) goto inf_leave;
 835                 zmemcpy(put, next, copy);
 836                 have -= copy;
 837                 next += copy;
 838                 left -= copy;
 839                 put += copy;
 840                 state->length -= copy;
 841                 break;
 842             }
 843             Tracev((stderr, "inflate:       stored end\n"));
 844             state->mode = TYPE;
 845             break;
 846         case TABLE:
 847             NEEDBITS(14);
 848             state->nlen = BITS(5) + 257;
 849             DROPBITS(5);
 850             state->ndist = BITS(5) + 1;
 851             DROPBITS(5);
 852             state->ncode = BITS(4) + 4;
 853             DROPBITS(4);
 854 #ifndef PKZIP_BUG_WORKAROUND
 855             if (state->nlen > 286 || state->ndist > 30) {
 856                 strm->msg = (char *)"too many length or distance symbols";
 857                 state->mode = BAD;
 858                 break;
 859             }
 860 #endif
 861             Tracev((stderr, "inflate:       table sizes ok\n"));
 862             state->have = 0;
 863             state->mode = LENLENS;
 864         case LENLENS:
 865             while (state->have < state->ncode) {
 866                 NEEDBITS(3);
 867                 state->lens[order[state->have++]] = (unsigned short)BITS(3);
 868                 DROPBITS(3);
 869             }
 870             while (state->have < 19)
 871                 state->lens[order[state->have++]] = 0;
 872             state->next = state->codes;
 873             state->lencode = (code const FAR *)(state->next);
 874             state->lenbits = 7;
 875             ret = inflate_table(CODES, state->lens, 19, &(state->next),
 876                                 &(state->lenbits), state->work);
 877             if (ret) {
 878                 strm->msg = (char *)"invalid code lengths set";
 879                 state->mode = BAD;
 880                 break;
 881             }
 882             Tracev((stderr, "inflate:       code lengths ok\n"));
 883             state->have = 0;
 884             state->mode = CODELENS;
 885         case CODELENS:
 886             while (state->have < state->nlen + state->ndist) {
 887                 for (;;) {
 888                     this = state->lencode[BITS(state->lenbits)];
 889                     if ((unsigned)(this.bits) <= bits) break;
 890                     PULLBYTE();
 891                 }
 892                 if (this.val < 16) {
 893                     NEEDBITS(this.bits);
 894                     DROPBITS(this.bits);
 895                     state->lens[state->have++] = this.val;
 896                 }
 897                 else {
 898                     if (this.val == 16) {
 899                         NEEDBITS(this.bits + 2);
 900                         DROPBITS(this.bits);
 901                         if (state->have == 0) {
 902                             strm->msg = (char *)"invalid bit length repeat";
 903                             state->mode = BAD;
 904                             break;
 905                         }
 906                         len = state->lens[state->have - 1];
 907                         copy = 3 + BITS(2);
 908                         DROPBITS(2);
 909                     }
 910                     else if (this.val == 17) {
 911                         NEEDBITS(this.bits + 3);
 912                         DROPBITS(this.bits);
 913                         len = 0;
 914                         copy = 3 + BITS(3);
 915                         DROPBITS(3);
 916                     }
 917                     else {
 918                         NEEDBITS(this.bits + 7);
 919                         DROPBITS(this.bits);
 920                         len = 0;
 921                         copy = 11 + BITS(7);
 922                         DROPBITS(7);
 923                     }
 924                     if (state->have + copy > state->nlen + state->ndist) {
 925                         strm->msg = (char *)"invalid bit length repeat";
 926                         state->mode = BAD;
 927                         break;
 928                     }
 929                     while (copy--)
 930                         state->lens[state->have++] = (unsigned short)len;
 931                 }
 932             }
 933
 934             /* handle error breaks in while */
 935             if (state->mode == BAD) break;
 936
 937             /* build code tables */
 938             state->next = state->codes;
 939             state->lencode = (code const FAR *)(state->next);
 940             state->lenbits = 9;
 941             ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
 942                                 &(state->lenbits), state->work);
 943             if (ret) {
 944                 strm->msg = (char *)"invalid literal/lengths set";
 945                 state->mode = BAD;
 946                 break;
 947             }
 948             state->distcode = (code const FAR *)(state->next);
 949             state->distbits = 6;
 950             ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
 951                             &(state->next), &(state->distbits), state->work);
 952             if (ret) {
 953                 strm->msg = (char *)"invalid distances set";
 954                 state->mode = BAD;
 955                 break;
 956             }
 957             Tracev((stderr, "inflate:       codes ok\n"));
 958             state->mode = LEN;
 959         case LEN:
 960             if (have >= 6 && left >= 258) {
 961                 RESTORE();
 962                 inflate_fast(strm, out);
 963                 LOAD();
 964                 break;
 965             }
 966             for (;;) {
 967                 this = state->lencode[BITS(state->lenbits)];
 968                 if ((unsigned)(this.bits) <= bits) break;
 969                 PULLBYTE();
 970             }
 971             if (this.op && (this.op & 0xf0) == 0) {
 972                 last = this;
 973                 for (;;) {
 974                     this = state->lencode[last.val +
 975                             (BITS(last.bits + last.op) >> last.bits)];
 976                     if ((unsigned)(last.bits + this.bits) <= bits) break;
 977                     PULLBYTE();
 978                 }
 979                 DROPBITS(last.bits);
 980             }
 981             DROPBITS(this.bits);
 982             state->length = (unsigned)this.val;
 983             if ((int)(this.op) == 0) {
 984                 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
 985                         "inflate:         literal '%c'\n" :
 986                         "inflate:         literal 0x%02x\n", this.val));
 987                 state->mode = LIT;
 988                 break;
 989             }
 990             if (this.op & 32) {
 991                 Tracevv((stderr, "inflate:         end of block\n"));
 992                 state->mode = TYPE;
 993                 break;
 994             }
 995             if (this.op & 64) {
 996                 strm->msg = (char *)"invalid literal/length code";
 997                 state->mode = BAD;
 998                 break;
 999             }
1000             state->extra = (unsigned)(this.op) & 15;
1001             state->mode = LENEXT;
1002         case LENEXT:
1003             if (state->extra) {
1004                 NEEDBITS(state->extra);
1005                 state->length += BITS(state->extra);
1006                 DROPBITS(state->extra);
1007             }
1008             Tracevv((stderr, "inflate:         length %u\n", state->length));
1009             state->mode = DIST;
1010         case DIST:
1011             for (;;) {
1012                 this = state->distcode[BITS(state->distbits)];
1013                 if ((unsigned)(this.bits) <= bits) break;
1014                 PULLBYTE();
1015             }
1016             if ((this.op & 0xf0) == 0) {
1017                 last = this;
1018                 for (;;) {
1019                     this = state->distcode[last.val +
1020                             (BITS(last.bits + last.op) >> last.bits)];
1021                     if ((unsigned)(last.bits + this.bits) <= bits) break;
1022                     PULLBYTE();
1023                 }
1024                 DROPBITS(last.bits);
1025             }
1026             DROPBITS(this.bits);
1027             if (this.op & 64) {
1028                 strm->msg = (char *)"invalid distance code";
1029                 state->mode = BAD;
1030                 break;
1031             }
1032             state->offset = (unsigned)this.val;
1033             state->extra = (unsigned)(this.op) & 15;
1034             state->mode = DISTEXT;
1035         case DISTEXT:
1036             if (state->extra) {
1037                 NEEDBITS(state->extra);
1038                 state->offset += BITS(state->extra);
1039                 DROPBITS(state->extra);
1040             }
1041 #ifdef INFLATE_STRICT
1042             if (state->offset > state->dmax) {
1043                 strm->msg = (char *)"invalid distance too far back";
1044                 state->mode = BAD;
1045                 break;
1046             }
1047 #endif
1048             if (state->offset > state->whave + out - left) {
1049                 strm->msg = (char *)"invalid distance too far back";
1050                 state->mode = BAD;
1051                 break;
1052             }
1053             Tracevv((stderr, "inflate:         distance %u\n", state->offset));
1054             state->mode = MATCH;
1055         case MATCH:
1056             if (left == 0) goto inf_leave;
1057             copy = out - left;
1058             if (state->offset > copy) {         /* copy from window */
1059                 copy = state->offset - copy;
1060                 if (copy > state->write) {
1061                     copy -= state->write;
1062                     from = state->window + (state->wsize - copy);
1063                 }
1064                 else
1065                     from = state->window + (state->write - copy);
1066                 if (copy > state->length) copy = state->length;
1067             }
1068             else {                              /* copy from output */
1069                 from = put - state->offset;
1070                 copy = state->length;
1071             }
1072             if (copy > left) copy = left;
1073             left -= copy;
1074             state->length -= copy;
1075             do {
1076                 *put++ = *from++;
1077             } while (--copy);
1078             if (state->length == 0) state->mode = LEN;
1079             break;
1080         case LIT:
1081             if (left == 0) goto inf_leave;
1082             *put++ = (unsigned char)(state->length);
1083             left--;
1084             state->mode = LEN;
1085             break;
1086         case CHECK:
1087             if (state->wrap) {
1088                 NEEDBITS(32);
1089                 out -= left;
1090                 strm->total_out += out;
1091                 state->total += out;
1092                 if (out)
1093                     strm->adler = state->check =
1094                         UPDATE(state->check, put - out, out);
1095                 out = left;
1096                 if ((
1097 #ifdef GUNZIP
1098                      state->flags ? hold :
1099 #endif
1100                      REVERSE(hold)) != state->check) {
1101                     strm->msg = (char *)"incorrect data check";
1102                     state->mode = BAD;
1103                     break;
1104                 }
1105                 INITBITS();
1106                 Tracev((stderr, "inflate:   check matches trailer\n"));
1107             }
1108 #ifdef GUNZIP
1109             state->mode = LENGTH;
1110         case LENGTH:
1111             if (state->wrap && state->flags) {
1112                 NEEDBITS(32);
1113                 if (hold != (state->total & 0xffffffffUL)) {
1114                     strm->msg = (char *)"incorrect length check";
1115                     state->mode = BAD;
1116                     break;
1117                 }
1118                 INITBITS();
1119                 Tracev((stderr, "inflate:   length matches trailer\n"));
1120             }
1121 #endif
1122             state->mode = DONE;
1123         case DONE:
1124             ret = Z_STREAM_END;
1125             goto inf_leave;
1126         case BAD:
1127             ret = Z_DATA_ERROR;
1128             goto inf_leave;
1129         case MEM:
1130             return Z_MEM_ERROR;
1131         case SYNC:
1132         default:
1133             return Z_STREAM_ERROR;
1134         }
1135
1136     /*
1137        Return from inflate(), updating the total counts and the check value.
1138        If there was no progress during the inflate() call, return a buffer
1139        error.  Call updatewindow() to create and/or update the window state.
1140        Note: a memory error from inflate() is non-recoverable.
1141      */
1142   inf_leave:
1143     RESTORE();
1144     if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
1145         if (updatewindow(strm, out)) {
1146             state->mode = MEM;
1147             return Z_MEM_ERROR;
1148         }
1149     in -= strm->avail_in;
1150     out -= strm->avail_out;
1151     strm->total_in += in;
1152     strm->total_out += out;
1153     state->total += out;
1154     if (state->wrap && out)
1155         strm->adler = state->check =
1156             UPDATE(state->check, strm->next_out - out, out);
1157     strm->data_type = state->bits + (state->last ? 64 : 0) +
1158                       (state->mode == TYPE ? 128 : 0);
1159     if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1160         ret = Z_BUF_ERROR;
1161     return ret;
1162 }
1163
1164 int ZEXPORT inflate_zr(strm, flush)
1165 z_streamp strm;
1166 int flush;
1167 {
1168     struct inflate_state FAR *state;
1169     unsigned char FAR *next;    /* next input */
1170     unsigned char FAR *put;     /* next output */
1171     unsigned have, left;        /* available input and output */
1172     unsigned long hold;         /* bit buffer */
1173     unsigned bits;              /* bits in bit buffer */
1174     unsigned in, out;           /* save starting available input and output */
1175     unsigned copy;              /* number of stored or match bytes to copy */
1176     unsigned char FAR *from;    /* where to copy match bytes from */
1177     code this;                  /* current decoding table entry */
1178     code last;                  /* parent table entry */
1179     unsigned len;               /* length to copy for repeats, bits to drop */
1180     int ret;                    /* return code */
1181 #ifdef GUNZIP
1182     unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
1183 #endif
1184     static const unsigned short order[19] = /* permutation of code lengths */
1185         {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
1186
1187     if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
1188         (strm->next_in == Z_NULL && strm->avail_in != 0))
1189         return Z_STREAM_ERROR;
1190
1191     state = (struct inflate_state FAR *)strm->state;
1192     if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
1193     LOAD();
1194     in = have;
1195     out = left;
1196     ret = Z_OK;
1197     for (;;)
1198         switch (state->mode) {
1199         case HEAD:
1200             if (state->wrap == 0) {
1201                 state->mode = TYPEDO;
1202                 break;
1203             }
1204             NEEDBITS(16);
1205 #ifdef GUNZIP
1206             if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
1207                 state->check = crc32(0L, Z_NULL, 0);
1208                 CRC2(state->check, hold);
1209                 INITBITS();
1210                 state->mode = FLAGS;
1211                 break;
1212             }
1213             state->flags = 0;           /* expect zlib header */
1214             if (state->head != Z_NULL)
1215                 state->head->done = -1;
1216             if (!(state->wrap & 1) ||   /* check if zlib header allowed */
1217 #else
1218             if (
1219 #endif
1220                 ((BITS(8) << 8) + (hold >> 8)) % 31) {
1221                 strm->msg = (char *)"incorrect header check";
1222                 state->mode = BAD;
1223                 break;
1224             }
1225             if (BITS(4) != Z_DEFLATED) {
1226                 strm->msg = (char *)"unknown compression method";
1227                 state->mode = BAD;
1228                 break;
1229             }
1230             DROPBITS(4);
1231             len = BITS(4) + 8;
1232             if (len > state->wbits) {
1233                 strm->msg = (char *)"invalid window size";
1234                 state->mode = BAD;
1235                 break;
1236             }
1237             state->dmax = 1U << len;
1238                         state->max_window_dist = 0;
1239                         state->dist_window_tail = 0;
1240                         state->dist_window = (unsigned short*)realloc(state->dist_window, state->dmax * sizeof(unsigned short));
1241                         memset(state->dist_window, 0, state->dmax * sizeof(unsigned short));
1242             Tracev((stderr, "inflate:   zlib header ok\n"));
1243             strm->adler = state->check = adler32(0L, Z_NULL, 0);
1244             state->mode = hold & 0x200 ? DICTID : TYPE;
1245             INITBITS();
1246             break;
1247 #ifdef GUNZIP
1248         case FLAGS:
1249             NEEDBITS(16);
1250             state->flags = (int)(hold);
1251             if ((state->flags & 0xff) != Z_DEFLATED) {
1252                 strm->msg = (char *)"unknown compression method";
1253                 state->mode = BAD;
1254                 break;
1255             }
1256             if (state->flags & 0xe000) {
1257                 strm->msg = (char *)"unknown header flags set";
1258                 state->mode = BAD;
1259                 break;
1260             }
1261             if (state->head != Z_NULL)
1262                 state->head->text = (int)((hold >> 8) & 1);
1263             if (state->flags & 0x0200) CRC2(state->check, hold);
1264             INITBITS();
1265             state->mode = TIME;
1266         case TIME:
1267             NEEDBITS(32);
1268             if (state->head != Z_NULL)
1269                 state->head->time = hold;
1270             if (state->flags & 0x0200) CRC4(state->check, hold);
1271             INITBITS();
1272             state->mode = OS;
1273         case OS:
1274             NEEDBITS(16);
1275             if (state->head != Z_NULL) {
1276                 state->head->xflags = (int)(hold & 0xff);
1277                 state->head->os = (int)(hold >> 8);
1278             }
1279             if (state->flags & 0x0200) CRC2(state->check, hold);
1280             INITBITS();
1281             state->mode = EXLEN;
1282         case EXLEN:
1283             if (state->flags & 0x0400) {
1284                 NEEDBITS(16);
1285                 state->length = (unsigned)(hold);
1286                 if (state->head != Z_NULL)
1287                     state->head->extra_len = (unsigned)hold;
1288                 if (state->flags & 0x0200) CRC2(state->check, hold);
1289                 INITBITS();
1290             }
1291             else if (state->head != Z_NULL)
1292                 state->head->extra = Z_NULL;
1293             state->mode = EXTRA;
1294         case EXTRA:
1295             if (state->flags & 0x0400) {
1296                 copy = state->length;
1297                 if (copy > have) copy = have;
1298                 if (copy) {
1299                     if (state->head != Z_NULL &&
1300                         state->head->extra != Z_NULL) {
1301                         len = state->head->extra_len - state->length;
1302                         zmemcpy(state->head->extra + len, next,
1303                                 len + copy > state->head->extra_max ?
1304                                 state->head->extra_max - len : copy);
1305                     }
1306                     if (state->flags & 0x0200)
1307                         state->check = crc32(state->check, next, copy);
1308                     have -= copy;
1309                     next += copy;
1310                     state->length -= copy;
1311                 }
1312                 if (state->length) goto inf_leave;
1313             }
1314             state->length = 0;
1315             state->mode = NAME;
1316         case NAME:
1317             if (state->flags & 0x0800) {
1318                 if (have == 0) goto inf_leave;
1319                 copy = 0;
1320                 do {
1321                     len = (unsigned)(next[copy++]);
1322                     if (state->head != Z_NULL &&
1323                             state->head->name != Z_NULL &&
1324                             state->length < state->head->name_max)
1325                         state->head->name[state->length++] = len;
1326                 } while (len && copy < have);
1327                 if (state->flags & 0x0200)
1328                     state->check = crc32(state->check, next, copy);
1329                 have -= copy;
1330                 next += copy;
1331                 if (len) goto inf_leave;
1332             }
1333             else if (state->head != Z_NULL)
1334                 state->head->name = Z_NULL;
1335             state->length = 0;
1336             state->mode = COMMENT;
1337         case COMMENT:
1338             if (state->flags & 0x1000) {
1339                 if (have == 0) goto inf_leave;
1340                 copy = 0;
1341                 do {
1342                     len = (unsigned)(next[copy++]);
1343                     if (state->head != Z_NULL &&
1344                             state->head->comment != Z_NULL &&
1345                             state->length < state->head->comm_max)
1346                         state->head->comment[state->length++] = len;
1347                 } while (len && copy < have);
1348                 if (state->flags & 0x0200)
1349                     state->check = crc32(state->check, next, copy);
1350                 have -= copy;
1351                 next += copy;
1352                 if (len) goto inf_leave;
1353             }
1354             else if (state->head != Z_NULL)
1355                 state->head->comment = Z_NULL;
1356             state->mode = HCRC;
1357         case HCRC:
1358             if (state->flags & 0x0200) {
1359                 NEEDBITS(16);
1360                 if (hold != (state->check & 0xffff)) {
1361                     strm->msg = (char *)"header crc mismatch";
1362                     state->mode = BAD;
1363                     break;
1364                 }
1365                 INITBITS();
1366             }
1367             if (state->head != Z_NULL) {
1368                 state->head->hcrc = (int)((state->flags >> 9) & 1);
1369                 state->head->done = 1;
1370             }
1371             strm->adler = state->check = crc32(0L, Z_NULL, 0);
1372             state->mode = TYPE;
1373             break;
1374 #endif
1375         case DICTID:
1376             NEEDBITS(32);
1377             strm->adler = state->check = REVERSE(hold);
1378             INITBITS();
1379             state->mode = DICT;
1380         case DICT:
1381             if (state->havedict == 0) {
1382                 RESTORE();
1383                 return Z_NEED_DICT;
1384             }
1385             strm->adler = state->check = adler32(0L, Z_NULL, 0);
1386             state->mode = TYPE;
1387         case TYPE:
1388             if (flush == Z_BLOCK) goto inf_leave;
1389         case TYPEDO:
1390             if (state->last) {
1391                 BYTEBITS();
1392                 state->mode = CHECK;
1393                 break;
1394             }
1395             NEEDBITS(3);
1396             state->last = BITS(1);
1397             DROPBITS(1);
1398             switch (BITS(2)) {
1399             case 0:                             /* stored block */
1400                 Tracev((stderr, "inflate:     stored block%s\n",
1401                         state->last ? " (last)" : ""));
1402                 state->mode = STORED;
1403                 break;
1404             case 1:                             /* fixed block */
1405                 fixedtables(state);
1406                 Tracev((stderr, "inflate:     fixed codes block%s\n",
1407                         state->last ? " (last)" : ""));
1408                 state->mode = LEN;              /* decode codes */
1409                 break;
1410             case 2:                             /* dynamic block */
1411                 Tracev((stderr, "inflate:     dynamic codes block%s\n",
1412                         state->last ? " (last)" : ""));
1413                 state->mode = TABLE;
1414                 break;
1415             case 3:
1416                 strm->msg = (char *)"invalid block type";
1417                 state->mode = BAD;
1418             }
1419             DROPBITS(2);
1420             break;
1421         case STORED:
1422             BYTEBITS();                         /* go to byte boundary */
1423             NEEDBITS(32);
1424             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
1425                 strm->msg = (char *)"invalid stored block lengths";
1426                 state->mode = BAD;
1427                 break;
1428             }
1429             state->length = (unsigned)hold & 0xffff;
1430             Tracev((stderr, "inflate:       stored length %u\n",
1431                     state->length));
1432             INITBITS();
1433             state->mode = COPY;
1434         case COPY:
1435             copy = state->length;
1436             if (copy) {
1437                 if (copy > have) copy = have;
1438                 if (copy > left) copy = left;
1439                 if (copy == 0) goto inf_leave;
1440                 zmemcpy(put, next, copy);
1441                 have -= copy;
1442                 next += copy;
1443                 left -= copy;
1444                 put += copy;
1445                 state->length -= copy;
1446                 break;
1447             }
1448             Tracev((stderr, "inflate:       stored end\n"));
1449             state->mode = TYPE;
1450             break;
1451         case TABLE:
1452             NEEDBITS(14);
1453             state->nlen = BITS(5) + 257;
1454             DROPBITS(5);
1455             state->ndist = BITS(5) + 1;
1456             DROPBITS(5);
1457             state->ncode = BITS(4) + 4;
1458             DROPBITS(4);
1459 #ifndef PKZIP_BUG_WORKAROUND
1460             if (state->nlen > 286 || state->ndist > 30) {
1461                 strm->msg = (char *)"too many length or distance symbols";
1462                 state->mode = BAD;
1463                 break;
1464             }
1465 #endif
1466             Tracev((stderr, "inflate:       table sizes ok\n"));
1467             state->have = 0;
1468             state->mode = LENLENS;
1469         case LENLENS:
1470             while (state->have < state->ncode) {
1471                 NEEDBITS(3);
1472                 state->lens[order[state->have++]] = (unsigned short)BITS(3);
1473                 DROPBITS(3);
1474             }
1475             while (state->have < 19)
1476                 state->lens[order[state->have++]] = 0;
1477             state->next = state->codes;
1478             state->lencode = (code const FAR *)(state->next);
1479             state->lenbits = 7;
1480             ret = inflate_table(CODES, state->lens, 19, &(state->next),
1481                                 &(state->lenbits), state->work);
1482             if (ret) {
1483                 strm->msg = (char *)"invalid code lengths set";
1484                 state->mode = BAD;
1485                 break;
1486             }
1487             Tracev((stderr, "inflate:       code lengths ok\n"));
1488             state->have = 0;
1489             state->mode = CODELENS;
1490         case CODELENS:
1491             while (state->have < state->nlen + state->ndist) {
1492                 for (;;) {
1493                     this = state->lencode[BITS(state->lenbits)];
1494                     if ((unsigned)(this.bits) <= bits) break;
1495                     PULLBYTE();
1496                 }
1497                 if (this.val < 16) {
1498                     NEEDBITS(this.bits);
1499                     DROPBITS(this.bits);
1500                     state->lens[state->have++] = this.val;
1501                 }
1502                 else {
1503                     if (this.val == 16) {
1504                         NEEDBITS(this.bits + 2);
1505                         DROPBITS(this.bits);
1506                         if (state->have == 0) {
1507                             strm->msg = (char *)"invalid bit length repeat";
1508                             state->mode = BAD;
1509                             break;
1510                         }
1511                         len = state->lens[state->have - 1];
1512                         copy = 3 + BITS(2);
1513                         DROPBITS(2);
1514                     }
1515                     else if (this.val == 17) {
1516                         NEEDBITS(this.bits + 3);
1517                         DROPBITS(this.bits);
1518                         len = 0;
1519                         copy = 3 + BITS(3);
1520                         DROPBITS(3);
1521                     }
1522                     else {
1523                         NEEDBITS(this.bits + 7);
1524                         DROPBITS(this.bits);
1525                         len = 0;
1526                         copy = 11 + BITS(7);
1527                         DROPBITS(7);
1528                     }
1529                     if (state->have + copy > state->nlen + state->ndist) {
1530                         strm->msg = (char *)"invalid bit length repeat";
1531                         state->mode = BAD;
1532                         break;
1533                     }
1534                     while (copy--)
1535                         state->lens[state->have++] = (unsigned short)len;
1536                 }
1537             }
1538
1539             /* handle error breaks in while */
1540             if (state->mode == BAD) break;
1541
1542             /* build code tables */
1543             state->next = state->codes;
1544             state->lencode = (code const FAR *)(state->next);
1545             state->lenbits = 9;
1546             ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1547                                 &(state->lenbits), state->work);
1548             if (ret) {
1549                 strm->msg = (char *)"invalid literal/lengths set";
1550                 state->mode = BAD;
1551                 break;
1552             }
1553             state->distcode = (code const FAR *)(state->next);
1554             state->distbits = 6;
1555             ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1556                             &(state->next), &(state->distbits), state->work);
1557             if (ret) {
1558                 strm->msg = (char *)"invalid distances set";
1559                 state->mode = BAD;
1560                 break;
1561             }
1562             Tracev((stderr, "inflate:       codes ok\n"));
1563             state->mode = LEN;
1564         case LEN:
1565             if (have >= 6 && left >= 258) {
1566                 RESTORE();
1567                 inflate_fast_zr(strm, out);
1568                 LOAD();
1569                 break;
1570             }
1571             for (;;) {
1572                 this = state->lencode[BITS(state->lenbits)];
1573                 if ((unsigned)(this.bits) <= bits) break;
1574                 PULLBYTE();
1575             }
1576             if (this.op && (this.op & 0xf0) == 0) {
1577                 last = this;
1578                 for (;;) {
1579                     this = state->lencode[last.val +
1580                             (BITS(last.bits + last.op) >> last.bits)];
1581                     if ((unsigned)(last.bits + this.bits) <= bits) break;
1582                     PULLBYTE();
1583                 }
1584                 DROPBITS(last.bits);
1585             }
1586             DROPBITS(this.bits);
1587             state->length = (unsigned)this.val;
1588             if ((int)(this.op) == 0) {
1589                 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
1590                         "inflate:         literal '%c'\n" :
1591                         "inflate:         literal 0x%02x\n", this.val));
1592                 state->mode = LIT;
1593                 break;
1594             }
1595             if (this.op & 32) {
1596                 Tracevv((stderr, "inflate:         end of block\n"));
1597                 state->mode = TYPE;
1598                 break;
1599             }
1600             if (this.op & 64) {
1601                 strm->msg = (char *)"invalid literal/length code";
1602                 state->mode = BAD;
1603                 break;
1604             }
1605             state->extra = (unsigned)(this.op) & 15;
1606             state->mode = LENEXT;
1607         case LENEXT:
1608             if (state->extra) {
1609                 NEEDBITS(state->extra);
1610                 state->length += BITS(state->extra);
1611                 DROPBITS(state->extra);
1612             }
1613             Tracevv((stderr, "inflate:         length %u\n", state->length));
1614             state->mode = DIST;
1615         case DIST:
1616             for (;;) {
1617                 this = state->distcode[BITS(state->distbits)];
1618                 if ((unsigned)(this.bits) <= bits) break;
1619                 PULLBYTE();
1620             }
1621             if ((this.op & 0xf0) == 0) {
1622                 last = this;
1623                 for (;;) {
1624                     this = state->distcode[last.val +
1625                             (BITS(last.bits + last.op) >> last.bits)];
1626                     if ((unsigned)(last.bits + this.bits) <= bits) break;
1627                     PULLBYTE();
1628                 }
1629                 DROPBITS(last.bits);
1630             }
1631             DROPBITS(this.bits);
1632             if (this.op & 64) {
1633                 strm->msg = (char *)"invalid distance code";
1634                 state->mode = BAD;
1635                 break;
1636             }
1637             state->offset = (unsigned)this.val;
1638             state->extra = (unsigned)(this.op) & 15;
1639             state->mode = DISTEXT;
1640         case DISTEXT:
1641             if (state->extra) {
1642                 NEEDBITS(state->extra);
1643                 state->offset += BITS(state->extra);
1644                 DROPBITS(state->extra);
1645             }
1646 #ifdef INFLATE_STRICT
1647             if (state->offset > state->dmax) {
1648                 strm->msg = (char *)"invalid distance too far back";
1649                 state->mode = BAD;
1650                 break;
1651             }
1652 #endif
1653             if (state->offset > state->whave + out - left) {
1654                 strm->msg = (char *)"invalid distance too far back";
1655                 state->mode = BAD;
1656                 break;
1657             }
1658             Tracevv((stderr, "inflate:         distance %u\n", state->offset));
1659             state->mode = MATCH;
1660         case MATCH:
1661             if (left == 0) goto inf_leave;
1662             copy = out - left;
1663             if (state->offset > copy) {         /* copy from window */
1664                 copy = state->offset - copy;
1665                 if (copy > state->write) {
1666                     copy -= state->write;
1667                     from = state->window + (state->wsize - copy);
1668                 }
1669                 else
1670                     from = state->window + (state->write - copy);
1671                 if (copy > state->length) copy = state->length;
1672             }
1673             else {                              /* copy from output */
1674                 from = put - state->offset;
1675                 copy = state->length;
1676             }
1677             if (copy > left) copy = left;
1678             left -= copy;
1679             state->length -= copy;
1680             do {
1681                 *put++ = *from++;
1682             } while (--copy);
1683             if (state->length == 0) state->mode = LEN;
1684             break;
1685         case LIT:
1686             if (left == 0) goto inf_leave;
1687             *put++ = (unsigned char)(state->length);
1688             left--;
1689             state->mode = LEN;
1690             break;
1691         case CHECK:
1692             if (state->wrap) {
1693                 NEEDBITS(32);
1694                 out -= left;
1695                 strm->total_out += out;
1696                 state->total += out;
1697                 if (out)
1698                     strm->adler = state->check =
1699                         UPDATE(state->check, put - out, out);
1700                 out = left;
1701                 if ((
1702 #ifdef GUNZIP
1703                      state->flags ? hold :
1704 #endif
1705                      REVERSE(hold)) != state->check) {
1706                     strm->msg = (char *)"incorrect data check";
1707                     state->mode = BAD;
1708                     break;
1709                 }
1710                 INITBITS();
1711                 Tracev((stderr, "inflate:   check matches trailer\n"));
1712             }
1713 #ifdef GUNZIP
1714             state->mode = LENGTH;
1715         case LENGTH:
1716             if (state->wrap && state->flags) {
1717                 NEEDBITS(32);
1718                 if (hold != (state->total & 0xffffffffUL)) {
1719                     strm->msg = (char *)"incorrect length check";
1720                     state->mode = BAD;
1721                     break;
1722                 }
1723                 INITBITS();
1724                 Tracev((stderr, "inflate:   length matches trailer\n"));
1725             }
1726 #endif
1727             state->mode = DONE;
1728         case DONE:
1729             ret = Z_STREAM_END;
1730             goto inf_leave;
1731         case BAD:
1732             ret = Z_DATA_ERROR;
1733             goto inf_leave;
1734         case MEM:
1735             return Z_MEM_ERROR;
1736         case SYNC:
1737         default:
1738             return Z_STREAM_ERROR;
1739         }
1740
1741     /*
1742        Return from inflate(), updating the total counts and the check value.
1743        If there was no progress during the inflate() call, return a buffer
1744        error.  Call updatewindow() to create and/or update the window state.
1745        Note: a memory error from inflate() is non-recoverable.
1746      */
1747   inf_leave:
1748     RESTORE();
1749     if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
1750         if (updatewindow(strm, out)) {
1751             state->mode = MEM;
1752             return Z_MEM_ERROR;
1753         }
1754     in -= strm->avail_in;
1755     out -= strm->avail_out;
1756     strm->total_in += in;
1757     strm->total_out += out;
1758     state->total += out;
1759     if (state->wrap && out)
1760         strm->adler = state->check =
1761             UPDATE(state->check, strm->next_out - out, out);
1762     strm->data_type = state->bits + (state->last ? 64 : 0) +
1763                       (state->mode == TYPE ? 128 : 0);
1764     if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1765         ret = Z_BUF_ERROR;
1766     return ret;
1767 }
1768 int ZEXPORT inflateEnd(strm)
1769 z_streamp strm;
1770 {
1771     struct inflate_state FAR *state;
1772     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
1773         return Z_STREAM_ERROR;
1774     state = (struct inflate_state FAR *)strm->state;
1775     if (state->window != Z_NULL) ZFREE(strm, state->window);
1776     if (state->dist_window != Z_NULL) ZFREE(strm, state->dist_window);
1777     ZFREE(strm, strm->state);
1778     strm->state = Z_NULL;
1779     Tracev((stderr, "inflate: end\n"));
1780     return Z_OK;
1781 }
1782
1783 int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
1784 z_streamp strm;
1785 const Bytef *dictionary;
1786 uInt dictLength;
1787 {
1788     struct inflate_state FAR *state;
1789     unsigned long id;
1790
1791     /* check state */
1792     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1793     state = (struct inflate_state FAR *)strm->state;
1794     if (state->wrap != 0 && state->mode != DICT)
1795         return Z_STREAM_ERROR;
1796
1797     /* check for correct dictionary id */
1798     if (state->mode == DICT) {
1799         id = adler32(0L, Z_NULL, 0);
1800         id = adler32(id, dictionary, dictLength);
1801         if (id != state->check)
1802             return Z_DATA_ERROR;
1803     }
1804
1805     /* copy dictionary to window */
1806     if (updatewindow(strm, strm->avail_out)) {
1807         state->mode = MEM;
1808         return Z_MEM_ERROR;
1809     }
1810     if (dictLength > state->wsize) {
1811         zmemcpy(state->window, dictionary + dictLength - state->wsize,
1812                 state->wsize);
1813         state->whave = state->wsize;
1814     }
1815     else {
1816         zmemcpy(state->window + state->wsize - dictLength, dictionary,
1817                 dictLength);
1818         state->whave = dictLength;
1819     }
1820     state->havedict = 1;
1821     Tracev((stderr, "inflate:   dictionary set\n"));
1822     return Z_OK;
1823 }
1824
1825 int ZEXPORT inflateGetHeader(strm, head)
1826 z_streamp strm;
1827 gz_headerp head;
1828 {
1829     struct inflate_state FAR *state;
1830
1831     /* check state */
1832     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1833     state = (struct inflate_state FAR *)strm->state;
1834     if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1835
1836     /* save header structure */
1837     state->head = head;
1838     head->done = 0;
1839     return Z_OK;
1840 }
1841
1842 /*
1843    Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
1844    or when out of input.  When called, *have is the number of pattern bytes
1845    found in order so far, in 0..3.  On return *have is updated to the new
1846    state.  If on return *have equals four, then the pattern was found and the
1847    return value is how many bytes were read including the last byte of the
1848    pattern.  If *have is less than four, then the pattern has not been found
1849    yet and the return value is len.  In the latter case, syncsearch() can be
1850    called again with more data and the *have state.  *have is initialized to
1851    zero for the first call.
1852  */
1853 local unsigned syncsearch(have, buf, len)
1854 unsigned FAR *have;
1855 unsigned char FAR *buf;
1856 unsigned len;
1857 {
1858     unsigned got;
1859     unsigned next;
1860
1861     got = *have;
1862     next = 0;
1863     while (next < len && got < 4) {
1864         if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
1865             got++;
1866         else if (buf[next])
1867             got = 0;
1868         else
1869             got = 4 - got;
1870         next++;
1871     }
1872     *have = got;
1873     return next;
1874 }
1875
1876 int ZEXPORT inflateSync(strm)
1877 z_streamp strm;
1878 {
1879     unsigned len;               /* number of bytes to look at or looked at */
1880     unsigned long in, out;      /* temporary to save total_in and total_out */
1881     unsigned char buf[4];       /* to restore bit buffer to byte string */
1882     struct inflate_state FAR *state;
1883
1884     /* check parameters */
1885     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1886     state = (struct inflate_state FAR *)strm->state;
1887     if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1888
1889     /* if first time, start search in bit buffer */
1890     if (state->mode != SYNC) {
1891         state->mode = SYNC;
1892         state->hold <<= state->bits & 7;
1893         state->bits -= state->bits & 7;
1894         len = 0;
1895         while (state->bits >= 8) {
1896             buf[len++] = (unsigned char)(state->hold);
1897             state->hold >>= 8;
1898             state->bits -= 8;
1899         }
1900         state->have = 0;
1901         syncsearch(&(state->have), buf, len);
1902     }
1903
1904     /* search available input */
1905     len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1906     strm->avail_in -= len;
1907     strm->next_in += len;
1908     strm->total_in += len;
1909
1910     /* return no joy or set up to restart inflate() on a new block */
1911     if (state->have != 4) return Z_DATA_ERROR;
1912     in = strm->total_in;  out = strm->total_out;
1913     inflateReset(strm);
1914     strm->total_in = in;  strm->total_out = out;
1915     state->mode = TYPE;
1916     return Z_OK;
1917 }
1918
1919 /*
1920    Returns true if inflate is currently at the end of a block generated by
1921    Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
1922    implementation to provide an additional safety check. PPP uses
1923    Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
1924    block. When decompressing, PPP checks that at the end of input packet,
1925    inflate is waiting for these length bytes.
1926  */
1927 int ZEXPORT inflateSyncPoint(strm)
1928 z_streamp strm;
1929 {
1930     struct inflate_state FAR *state;
1931
1932     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1933     state = (struct inflate_state FAR *)strm->state;
1934     return state->mode == STORED && state->bits == 0;
1935 }
1936
1937 int ZEXPORT inflateCopy(dest, source)
1938 z_streamp dest;
1939 z_streamp source;
1940 {
1941     struct inflate_state FAR *state;
1942     struct inflate_state FAR *copy;
1943     unsigned char FAR *window;
1944     unsigned wsize;
1945
1946     /* check input */
1947     if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
1948         source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
1949         return Z_STREAM_ERROR;
1950     state = (struct inflate_state FAR *)source->state;
1951
1952     /* allocate space */
1953     copy = (struct inflate_state FAR *)
1954            ZALLOC(source, 1, sizeof(struct inflate_state));
1955     if (copy == Z_NULL) return Z_MEM_ERROR;
1956     window = Z_NULL;
1957     if (state->window != Z_NULL) {
1958         window = (unsigned char FAR *)
1959                  ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1960         if (window == Z_NULL) {
1961             ZFREE(source, copy);
1962             return Z_MEM_ERROR;
1963         }
1964     }
1965
1966     /* copy state */
1967     zmemcpy(dest, source, sizeof(z_stream));
1968     zmemcpy(copy, state, sizeof(struct inflate_state));
1969     if (state->lencode >= state->codes &&
1970         state->lencode <= state->codes + ENOUGH - 1) {
1971         copy->lencode = copy->codes + (state->lencode - state->codes);
1972         copy->distcode = copy->codes + (state->distcode - state->codes);
1973     }
1974     copy->next = copy->codes + (state->next - state->codes);
1975     if (window != Z_NULL) {
1976         wsize = 1U << state->wbits;
1977         zmemcpy(window, state->window, wsize);
1978     }
1979     copy->window = window;
1980     dest->state = (struct internal_state FAR *)copy;
1981     return Z_OK;
1982 }