root/lib/libz/inflate.c

DEFINITIONS

1. inflateReset
2. inflatePrime
3. inflateInit2_
4. inflateInit_
5. fixedtables
6. makefixed
7. updatewindow
8. inflate
9. inflateEnd
10. inflateSetDictionary
11. inflateGetHeader
12. syncsearch
13. inflateSync
14. inflateSyncPoint
15. inflateCopy

    1 /*      $OpenBSD: inflate.c,v 1.13 2005/07/20 15:56:46 millert Exp $    */
    2 /* inflate.c -- zlib decompression
    3  * Copyright (C) 1995-2005 Mark Adler
    4  * For conditions of distribution and use, see copyright notice in zlib.h
    5  */
    7 /*
    8  * Change history:
    9  *
   10  * 1.2.beta0    24 Nov 2002
   11  * - First version -- complete rewrite of inflate to simplify code, avoid
   12  *   creation of window when not needed, minimize use of window when it is
   13  *   needed, make inffast.c even faster, implement gzip decoding, and to
   14  *   improve code readability and style over the previous zlib inflate code
   15  *
   16  * 1.2.beta1    25 Nov 2002
   17  * - Use pointers for available input and output checking in inffast.c
   18  * - Remove input and output counters in inffast.c
   19  * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
   20  * - Remove unnecessary second byte pull from length extra in inffast.c
   21  * - Unroll direct copy to three copies per loop in inffast.c
   22  *
   23  * 1.2.beta2    4 Dec 2002
   24  * - Change external routine names to reduce potential conflicts
   25  * - Correct filename to inffixed.h for fixed tables in inflate.c
   26  * - Make hbuf[] unsigned char to match parameter type in inflate.c
   27  * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
   28  *   to avoid negation problem on Alphas (64 bit) in inflate.c
   29  *
   30  * 1.2.beta3    22 Dec 2002
   31  * - Add comments on state->bits assertion in inffast.c
   32  * - Add comments on op field in inftrees.h
   33  * - Fix bug in reuse of allocated window after inflateReset()
   34  * - Remove bit fields--back to byte structure for speed
   35  * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
   36  * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
   37  * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
   38  * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
   39  * - Use local copies of stream next and avail values, as well as local bit
   40  *   buffer and bit count in inflate()--for speed when inflate_fast() not used
   41  *
   42  * 1.2.beta4    1 Jan 2003
   43  * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
   44  * - Move a comment on output buffer sizes from inffast.c to inflate.c
   45  * - Add comments in inffast.c to introduce the inflate_fast() routine
   46  * - Rearrange window copies in inflate_fast() for speed and simplification
   47  * - Unroll last copy for window match in inflate_fast()
   48  * - Use local copies of window variables in inflate_fast() for speed
   49  * - Pull out common write == 0 case for speed in inflate_fast()
   50  * - Make op and len in inflate_fast() unsigned for consistency
   51  * - Add FAR to lcode and dcode declarations in inflate_fast()
   52  * - Simplified bad distance check in inflate_fast()
   53  * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
   54  *   source file infback.c to provide a call-back interface to inflate for
   55  *   programs like gzip and unzip -- uses window as output buffer to avoid
   56  *   window copying
   57  *
   58  * 1.2.beta5    1 Jan 2003
   59  * - Improved inflateBack() interface to allow the caller to provide initial
   60  *   input in strm.
   61  * - Fixed stored blocks bug in inflateBack()
   62  *
   63  * 1.2.beta6    4 Jan 2003
   64  * - Added comments in inffast.c on effectiveness of POSTINC
   65  * - Typecasting all around to reduce compiler warnings
   66  * - Changed loops from while (1) or do {} while (1) to for (;;), again to
   67  *   make compilers happy
   68  * - Changed type of window in inflateBackInit() to unsigned char *
   69  *
   70  * 1.2.beta7    27 Jan 2003
   71  * - Changed many types to unsigned or unsigned short to avoid warnings
   72  * - Added inflateCopy() function
   73  *
   74  * 1.2.0        9 Mar 2003
   75  * - Changed inflateBack() interface to provide separate opaque descriptors
   76  *   for the in() and out() functions
   77  * - Changed inflateBack() argument and in_func typedef to swap the length
   78  *   and buffer address return values for the input function
   79  * - Check next_in and next_out for Z_NULL on entry to inflate()
   80  *
   81  * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
   82  */
   84 #include "zutil.h"
   85 #include "inftrees.h"
   86 #include "inflate.h"
   87 #include "inffast.h"
   89 #ifdef MAKEFIXED
   90 #  ifndef BUILDFIXED
   91 #    define BUILDFIXED
   92 #  endif
   93 #endif
   95 /* function prototypes */
local void fixedtables OF((struct inflate_state FAR *state));
local int updatewindow OF((z_streamp strm, unsigned out));
   98 #ifdef BUILDFIXED
   99    void makefixed OF((void));
  100 #endif
local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
  102                               unsigned len));
  104 int ZEXPORT inflateReset(strm)
z_streamp strm;
  106 {
  107     struct inflate_state FAR *state;
  109     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
strm->total_in = strm->total_out = state->total = 0;
strm->msg = Z_NULL;
strm->adler = 1;        /* to support ill-conceived Java test suite */
state->mode = HEAD;
state->last = 0;
state->havedict = 0;
state->dmax = 32768U;
state->head = Z_NULL;
state->wsize = 0;
state->whave = 0;
state->write = 0;
state->hold = 0;
state->bits = 0;
state->lencode = state->distcode = state->next = state->codes;
Tracev((stderr, "inflate: reset\n"));
  126     return Z_OK;
  127 }
  129 int ZEXPORT inflatePrime(strm, bits, value)
z_streamp strm;
  131 int bits;
  132 int value;
  133 {
  134     struct inflate_state FAR *state;
  136     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
  138     if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
value &= (1L << bits) - 1;
state->hold += value << state->bits;
state->bits += bits;
  142     return Z_OK;
  143 }
  145 int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
z_streamp strm;
  147 int windowBits;
  148 const char *version;
  149 int stream_size;
  150 {
  151     struct inflate_state FAR *state;
  153     if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
stream_size != (int)(sizeof(z_stream)))
  155         return Z_VERSION_ERROR;
  156     if (strm == Z_NULL) return Z_STREAM_ERROR;
strm->msg = Z_NULL;                 /* in case we return an error */
  158     if (strm->zalloc == (alloc_func)0) {
strm->zalloc = zcalloc;
strm->opaque = (voidpf)0;
  161     }
  162     if (strm->zfree == (free_func)0) strm->zfree = zcfree;
state = (struct inflate_state FAR *)
ZALLOC(strm, 1, sizeof(struct inflate_state));
  165     if (state == Z_NULL) return Z_MEM_ERROR;
Tracev((stderr, "inflate: allocated\n"));
strm->state = (struct internal_state FAR *)state;
  168     if (windowBits < 0) {
state->wrap = 0;
windowBits = -windowBits;
  171     }
  172     else {
state->wrap = (windowBits >> 4) + 1;
  174 #ifdef GUNZIP
  175         if (windowBits < 48) windowBits &= 15;
  176 #endif
  177     }
  178     if (windowBits < 8 || windowBits > 15) {
ZFREE(strm, state);
strm->state = Z_NULL;
  181         return Z_STREAM_ERROR;
  182     }
state->wbits = (unsigned)windowBits;
state->window = Z_NULL;
  185     return inflateReset(strm);
  186 }
  188 int ZEXPORT inflateInit_(strm, version, stream_size)
z_streamp strm;
  190 const char *version;
  191 int stream_size;
  192 {
  193     return inflateInit2_(strm, DEF_WBITS, version, stream_size);
  194 }
  196 /*
  197    Return state with length and distance decoding tables and index sizes set to
  198    fixed code decoding.  Normally this returns fixed tables from inffixed.h.
  199    If BUILDFIXED is defined, then instead this routine builds the tables the
  200    first time it's called, and returns those tables the first time and
  201    thereafter.  This reduces the size of the code by about 2K bytes, in
  202    exchange for a little execution time.  However, BUILDFIXED should not be
  203    used for threaded applications, since the rewriting of the tables and virgin
  204    may not be thread-safe.
  205  */
local void fixedtables(state)
  207 struct inflate_state FAR *state;
  208 {
  209 #ifdef BUILDFIXED
  210     static int virgin = 1;
  211     static code *lenfix, *distfix;
  212     static code fixed[544];
  214     /* build fixed huffman tables if first call (may not be thread safe) */
  215     if (virgin) {
  216         unsigned sym, bits;
  217         static code *next;
  219         /* literal/length table */
sym = 0;
  221         while (sym < 144) state->lens[sym++] = 8;
  222         while (sym < 256) state->lens[sym++] = 9;
  223         while (sym < 280) state->lens[sym++] = 7;
  224         while (sym < 288) state->lens[sym++] = 8;
next = fixed;
lenfix = next;
bits = 9;
inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
  230         /* distance table */
sym = 0;
  232         while (sym < 32) state->lens[sym++] = 5;
distfix = next;
bits = 5;
inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
  237         /* do this just once */
virgin = 0;
  239     }
  240 #else /* !BUILDFIXED */
  241 #   include "inffixed.h"
  242 #endif /* BUILDFIXED */
state->lencode = lenfix;
state->lenbits = 9;
state->distcode = distfix;
state->distbits = 5;
  247 }
  249 #ifdef MAKEFIXED
  250 #include <stdio.h>
  252 /*
  253    Write out the inffixed.h that is #include'd above.  Defining MAKEFIXED also
  254    defines BUILDFIXED, so the tables are built on the fly.  makefixed() writes
  255    those tables to stdout, which would be piped to inffixed.h.  A small program
  256    can simply call makefixed to do this:
  257 
  258     void makefixed(void);
  259 
  260     int main(void)
  261     {
  262         makefixed();
  263         return 0;
  264     }
  265 
  266    Then that can be linked with zlib built with MAKEFIXED defined and run:
  267 
  268     a.out > inffixed.h
  269  */
  270 void makefixed()
  271 {
  272     unsigned low, size;
  273     struct inflate_state state;
fixedtables(&state);
puts("    /* inffixed.h -- table for decoding fixed codes");
puts("     * Generated automatically by makefixed().");
puts("     */");
puts("");
puts("    /* WARNING: this file should *not* be used by applications.");
puts("       It is part of the implementation of this library and is");
puts("       subject to change. Applications should only use zlib.h.");
puts("     */");
puts("");
size = 1U << 9;
printf("    static const code lenfix[%u] = {", size);
low = 0;
  288     for (;;) {
  289         if ((low % 7) == 0) printf("\n        ");
printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
state.lencode[low].val);
  292         if (++low == size) break;
putchar(',');
  294     }
puts("\n    };");
size = 1U << 5;
printf("\n    static const code distfix[%u] = {", size);
low = 0;
  299     for (;;) {
  300         if ((low % 6) == 0) printf("\n        ");
printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
state.distcode[low].val);
  303         if (++low == size) break;
putchar(',');
  305     }
puts("\n    };");
  307 }
  308 #endif /* MAKEFIXED */
  310 /*
  311    Update the window with the last wsize (normally 32K) bytes written before
  312    returning.  If window does not exist yet, create it.  This is only called
  313    when a window is already in use, or when output has been written during this
  314    inflate call, but the end of the deflate stream has not been reached yet.
  315    It is also called to create a window for dictionary data when a dictionary
  316    is loaded.
  317 
  318    Providing output buffers larger than 32K to inflate() should provide a speed
  319    advantage, since only the last 32K of output is copied to the sliding window
  320    upon return from inflate(), and since all distances after the first 32K of
  321    output will fall in the output data, making match copies simpler and faster.
  322    The advantage may be dependent on the size of the processor's data caches.
  323  */
local int updatewindow(strm, out)
z_streamp strm;
  326 unsigned out;
  327 {
  328     struct inflate_state FAR *state;
  329     unsigned copy, dist;
state = (struct inflate_state FAR *)strm->state;
  333     /* if it hasn't been done already, allocate space for the window */
  334     if (state->window == Z_NULL) {
state->window = (unsigned char FAR *)
ZALLOC(strm, 1U << state->wbits,
  337                                sizeof(unsigned char));
  338         if (state->window == Z_NULL) return 1;
  339     }
  341     /* if window not in use yet, initialize */
  342     if (state->wsize == 0) {
state->wsize = 1U << state->wbits;
state->write = 0;
state->whave = 0;
  346     }
  348     /* copy state->wsize or less output bytes into the circular window */
copy = out - strm->avail_out;
  350     if (copy >= state->wsize) {
zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
state->write = 0;
state->whave = state->wsize;
  354     }
  355     else {
dist = state->wsize - state->write;
  357         if (dist > copy) dist = copy;
zmemcpy(state->window + state->write, strm->next_out - copy, dist);
copy -= dist;
  360         if (copy) {
zmemcpy(state->window, strm->next_out - copy, copy);
state->write = copy;
state->whave = state->wsize;
  364         }
  365         else {
state->write += dist;
  367             if (state->write == state->wsize) state->write = 0;
  368             if (state->whave < state->wsize) state->whave += dist;
  369         }
  370     }
  371     return 0;
  372 }
  374 /* Macros for inflate(): */
  376 /* check function to use adler32() for zlib or crc32() for gzip */
  377 #ifdef GUNZIP
  378 #  define UPDATE(check, buf, len) \
  379     (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
  380 #else
  381 #  define UPDATE(check, buf, len) adler32(check, buf, len)
  382 #endif
  384 /* check macros for header crc */
  385 #ifdef GUNZIP
  386 #  define CRC2(check, word) \
  387     do { \
hbuf[0] = (unsigned char)(word); \
hbuf[1] = (unsigned char)((word) >> 8); \
check = crc32(check, hbuf, 2); \
  391     } while (0)
  393 #  define CRC4(check, word) \
  394     do { \
hbuf[0] = (unsigned char)(word); \
hbuf[1] = (unsigned char)((word) >> 8); \
hbuf[2] = (unsigned char)((word) >> 16); \
hbuf[3] = (unsigned char)((word) >> 24); \
check = crc32(check, hbuf, 4); \
  400     } while (0)
  401 #endif
  403 /* Load registers with state in inflate() for speed */
  404 #define LOAD() \
  405     do { \
put = strm->next_out; \
left = strm->avail_out; \
next = strm->next_in; \
have = strm->avail_in; \
hold = state->hold; \
bits = state->bits; \
  412     } while (0)
  414 /* Restore state from registers in inflate() */
  415 #define RESTORE() \
  416     do { \
strm->next_out = put; \
strm->avail_out = left; \
strm->next_in = next; \
strm->avail_in = have; \
state->hold = hold; \
state->bits = bits; \
  423     } while (0)
  425 /* Clear the input bit accumulator */
  426 #define INITBITS() \
  427     do { \
hold = 0; \
bits = 0; \
  430     } while (0)
  432 /* Get a byte of input into the bit accumulator, or return from inflate()
  433    if there is no input available. */
  434 #define PULLBYTE() \
  435     do { \
  436         if (have == 0) goto inf_leave; \
have--; \
hold += (unsigned long)(*next++) << bits; \
bits += 8; \
  440     } while (0)
  442 /* Assure that there are at least n bits in the bit accumulator.  If there is
  443    not enough available input to do that, then return from inflate(). */
  444 #define NEEDBITS(n) \
  445     do { \
  446         while (bits < (unsigned)(n)) \
PULLBYTE(); \
  448     } while (0)
  450 /* Return the low n bits of the bit accumulator (n < 16) */
  451 #define BITS(n) \
  452     ((unsigned)hold & ((1U << (n)) - 1))
  454 /* Remove n bits from the bit accumulator */
  455 #define DROPBITS(n) \
  456     do { \
hold >>= (n); \
bits -= (unsigned)(n); \
  459     } while (0)
  461 /* Remove zero to seven bits as needed to go to a byte boundary */
  462 #define BYTEBITS() \
  463     do { \
hold >>= bits & 7; \
bits -= bits & 7; \
  466     } while (0)
  468 /* Reverse the bytes in a 32-bit value */
  469 #define REVERSE(q) \
  470     ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
  471      (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
  473 /*
  474    inflate() uses a state machine to process as much input data and generate as
  475    much output data as possible before returning.  The state machine is
  476    structured roughly as follows:
  477 
  478     for (;;) switch (state) {
  479     ...
  480     case STATEn:
  481         if (not enough input data or output space to make progress)
  482             return;
  483         ... make progress ...
  484         state = STATEm;
  485         break;
  486     ...
  487     }
  488 
  489    so when inflate() is called again, the same case is attempted again, and
  490    if the appropriate resources are provided, the machine proceeds to the
  491    next state.  The NEEDBITS() macro is usually the way the state evaluates
  492    whether it can proceed or should return.  NEEDBITS() does the return if
  493    the requested bits are not available.  The typical use of the BITS macros
  494    is:
  495 
  496         NEEDBITS(n);
  497         ... do something with BITS(n) ...
  498         DROPBITS(n);
  499 
  500    where NEEDBITS(n) either returns from inflate() if there isn't enough
  501    input left to load n bits into the accumulator, or it continues.  BITS(n)
  502    gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
  503    the low n bits off the accumulator.  INITBITS() clears the accumulator
  504    and sets the number of available bits to zero.  BYTEBITS() discards just
  505    enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
  506    and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
  507 
  508    NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
  509    if there is no input available.  The decoding of variable length codes uses
  510    PULLBYTE() directly in order to pull just enough bytes to decode the next
  511    code, and no more.
  512 
  513    Some states loop until they get enough input, making sure that enough
  514    state information is maintained to continue the loop where it left off
  515    if NEEDBITS() returns in the loop.  For example, want, need, and keep
  516    would all have to actually be part of the saved state in case NEEDBITS()
  517    returns:
  518 
  519     case STATEw:
  520         while (want < need) {
  521             NEEDBITS(n);
  522             keep[want++] = BITS(n);
  523             DROPBITS(n);
  524         }
  525         state = STATEx;
  526     case STATEx:
  527 
  528    As shown above, if the next state is also the next case, then the break
  529    is omitted.
  530 
  531    A state may also return if there is not enough output space available to
  532    complete that state.  Those states are copying stored data, writing a
  533    literal byte, and copying a matching string.
  534 
  535    When returning, a "goto inf_leave" is used to update the total counters,
  536    update the check value, and determine whether any progress has been made
  537    during that inflate() call in order to return the proper return code.
  538    Progress is defined as a change in either strm->avail_in or strm->avail_out.
  539    When there is a window, goto inf_leave will update the window with the last
  540    output written.  If a goto inf_leave occurs in the middle of decompression
  541    and there is no window currently, goto inf_leave will create one and copy
  542    output to the window for the next call of inflate().
  543 
  544    In this implementation, the flush parameter of inflate() only affects the
  545    return code (per zlib.h).  inflate() always writes as much as possible to
  546    strm->next_out, given the space available and the provided input--the effect
  547    documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
  548    the allocation of and copying into a sliding window until necessary, which
  549    provides the effect documented in zlib.h for Z_FINISH when the entire input
  550    stream available.  So the only thing the flush parameter actually does is:
  551    when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
  552    will return Z_BUF_ERROR if it has not reached the end of the stream.
  553  */
  555 int ZEXPORT inflate(strm, flush)
z_streamp strm;
  557 int flush;
  558 {
  559     struct inflate_state FAR *state;
  560     unsigned char FAR *next;    /* next input */
  561     unsigned char FAR *put;     /* next output */
  562     unsigned have, left;        /* available input and output */
  563     unsigned long hold;         /* bit buffer */
  564     unsigned bits;              /* bits in bit buffer */
  565     unsigned in, out;           /* save starting available input and output */
  566     unsigned copy;              /* number of stored or match bytes to copy */
  567     unsigned char FAR *from;    /* where to copy match bytes from */
code this;                  /* current decoding table entry */
code last;                  /* parent table entry */
  570     unsigned len;               /* length to copy for repeats, bits to drop */
  571     int ret;                    /* return code */
  572 #ifdef GUNZIP
  573     unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
  574 #endif
  575     static const unsigned short order[19] = /* permutation of code lengths */
  576         {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
  578     if (strm == Z_NULL || strm->state == Z_NULL ||
  579 #ifndef __vax__
strm->next_out == Z_NULL ||
  581 #endif
  582         (strm->next_in == Z_NULL && strm->avail_in != 0))
  583         return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
  586     if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
LOAD();
in = have;
out = left;
ret = Z_OK;
  591     for (;;)
  592         switch (state->mode) {
  593         case HEAD:
  594             if (state->wrap == 0) {
state->mode = TYPEDO;
  596                 break;
  597             }
NEEDBITS(16);
  599 #ifdef GUNZIP
  600             if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
state->check = crc32(0L, Z_NULL, 0);
CRC2(state->check, hold);
INITBITS();
state->mode = FLAGS;
  605                 break;
  606             }
state->flags = 0;           /* expect zlib header */
  608             if (state->head != Z_NULL)
state->head->done = -1;
  610             if (!(state->wrap & 1) ||   /* check if zlib header allowed */
  611 #else
  612             if (
  613 #endif
  614                 ((BITS(8) << 8) + (hold >> 8)) % 31) {
  615 #ifdef SMALL  
strm->msg = "error";
  617 #else
strm->msg = (char *)"incorrect header check";
  619 #endif
state->mode = BAD;
  621                 break;
  622             }
  623             if (BITS(4) != Z_DEFLATED) {
  624 #ifdef SMALL  
strm->msg = "error";
  626 #else
strm->msg = (char *)"unknown compression method";
  628 #endif
state->mode = BAD;
  630                 break;
  631             }
DROPBITS(4);
len = BITS(4) + 8;
  634             if (len > state->wbits) {
  635 #ifdef SMALL  
strm->msg = "error";
  637 #else
strm->msg = (char *)"invalid window size";
  639 #endif
state->mode = BAD;
  641                 break;
  642             }
state->dmax = 1U << len;
Tracev((stderr, "inflate:   zlib header ok\n"));
strm->adler = state->check = adler32(0L, Z_NULL, 0);
state->mode = hold & 0x200 ? DICTID : TYPE;
INITBITS();
  648             break;
  649 #ifdef GUNZIP
  650         case FLAGS:
NEEDBITS(16);
state->flags = (int)(hold);
  653             if ((state->flags & 0xff) != Z_DEFLATED) {
  654 #ifdef SMALL  
strm->msg = "error";
  656 #else
strm->msg = (char *)"unknown compression method";
  658 #endif
state->mode = BAD;
  660                 break;
  661             }
  662             if (state->flags & 0xe000) {
  663 #ifdef SMALL  
strm->msg = "error";
  665 #else
strm->msg = (char *)"unknown header flags set";
  667 #endif
state->mode = BAD;
  669                 break;
  670             }
  671             if (state->head != Z_NULL)
state->head->text = (int)((hold >> 8) & 1);
  673             if (state->flags & 0x0200) CRC2(state->check, hold);
INITBITS();
state->mode = TIME;
  676         case TIME:
NEEDBITS(32);
  678             if (state->head != Z_NULL)
state->head->time = hold;
  680             if (state->flags & 0x0200) CRC4(state->check, hold);
INITBITS();
state->mode = OS;
  683         case OS:
NEEDBITS(16);
  685             if (state->head != Z_NULL) {
state->head->xflags = (int)(hold & 0xff);
state->head->os = (int)(hold >> 8);
  688             }
  689             if (state->flags & 0x0200) CRC2(state->check, hold);
INITBITS();
state->mode = EXLEN;
  692         case EXLEN:
  693             if (state->flags & 0x0400) {
NEEDBITS(16);
state->length = (unsigned)(hold);
  696                 if (state->head != Z_NULL)
state->head->extra_len = (unsigned)hold;
  698                 if (state->flags & 0x0200) CRC2(state->check, hold);
INITBITS();
  700             }
  701             else if (state->head != Z_NULL)
state->head->extra = Z_NULL;
state->mode = EXTRA;
  704         case EXTRA:
  705             if (state->flags & 0x0400) {
copy = state->length;
  707                 if (copy > have) copy = have;
  708                 if (copy) {
  709                     if (state->head != Z_NULL &&
state->head->extra != Z_NULL) {
len = state->head->extra_len - state->length;
zmemcpy(state->head->extra + len, next,
len + copy > state->head->extra_max ?
state->head->extra_max - len : copy);
  715                     }
  716                     if (state->flags & 0x0200)
state->check = crc32(state->check, next, copy);
have -= copy;
next += copy;
state->length -= copy;
  721                 }
  722                 if (state->length) goto inf_leave;
  723             }
state->length = 0;
state->mode = NAME;
  726         case NAME:
  727             if (state->flags & 0x0800) {
  728                 if (have == 0) goto inf_leave;
copy = 0;
  730                 do {
len = (unsigned)(next[copy++]);
  732                     if (state->head != Z_NULL &&
state->head->name != Z_NULL &&
state->length < state->head->name_max)
state->head->name[state->length++] = len;
  736                 } while (len && copy < have);
  737                 if (state->flags & 0x0200)
state->check = crc32(state->check, next, copy);
have -= copy;
next += copy;
  741                 if (len) goto inf_leave;
  742             }
  743             else if (state->head != Z_NULL)
state->head->name = Z_NULL;
state->length = 0;
state->mode = COMMENT;
  747         case COMMENT:
  748             if (state->flags & 0x1000) {
  749                 if (have == 0) goto inf_leave;
copy = 0;
  751                 do {
len = (unsigned)(next[copy++]);
  753                     if (state->head != Z_NULL &&
state->head->comment != Z_NULL &&
state->length < state->head->comm_max)
state->head->comment[state->length++] = len;
  757                 } while (len && copy < have);
  758                 if (state->flags & 0x0200)
state->check = crc32(state->check, next, copy);
have -= copy;
next += copy;
  762                 if (len) goto inf_leave;
  763             }
  764             else if (state->head != Z_NULL)
state->head->comment = Z_NULL;
state->mode = HCRC;
  767         case HCRC:
  768             if (state->flags & 0x0200) {
NEEDBITS(16);
  770                 if (hold != (state->check & 0xffff)) {
  771 #ifdef SMALL  
strm->msg = "error";
  773 #else
strm->msg = (char *)"header crc mismatch";
  775 #endif
state->mode = BAD;
  777                     break;
  778                 }
INITBITS();
  780             }
  781             if (state->head != Z_NULL) {
state->head->hcrc = (int)((state->flags >> 9) & 1);
state->head->done = 1;
  784             }
strm->adler = state->check = crc32(0L, Z_NULL, 0);
state->mode = TYPE;
  787             break;
  788 #endif
  789         case DICTID:
NEEDBITS(32);
strm->adler = state->check = REVERSE(hold);
INITBITS();
state->mode = DICT;
  794         case DICT:
  795             if (state->havedict == 0) {
RESTORE();
  797                 return Z_NEED_DICT;
  798             }
strm->adler = state->check = adler32(0L, Z_NULL, 0);
state->mode = TYPE;
  801         case TYPE:
  802             if (flush == Z_BLOCK) goto inf_leave;
  803         case TYPEDO:
  804             if (state->last) {
BYTEBITS();
state->mode = CHECK;
  807                 break;
  808             }
NEEDBITS(3);
state->last = BITS(1);
DROPBITS(1);
  812             switch (BITS(2)) {
  813             case 0:                             /* stored block */
Tracev((stderr, "inflate:     stored block%s\n",
state->last ? " (last)" : ""));
state->mode = STORED;
  817                 break;
  818             case 1:                             /* fixed block */
fixedtables(state);
Tracev((stderr, "inflate:     fixed codes block%s\n",
state->last ? " (last)" : ""));
state->mode = LEN;              /* decode codes */
  823                 break;
  824             case 2:                             /* dynamic block */
Tracev((stderr, "inflate:     dynamic codes block%s\n",
state->last ? " (last)" : ""));
state->mode = TABLE;
  828                 break;
  829             case 3:
  830 #ifdef SMALL  
strm->msg = "error";
  832 #else
strm->msg = (char *)"invalid block type";
  834 #endif
state->mode = BAD;
  836             }
DROPBITS(2);
  838             break;
  839         case STORED:
BYTEBITS();                         /* go to byte boundary */
NEEDBITS(32);
  842             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
  843 #ifdef SMALL  
strm->msg = "error";
  845 #else
strm->msg = (char *)"invalid stored block lengths";
  847 #endif
state->mode = BAD;
  849                 break;
  850             }
state->length = (unsigned)hold & 0xffff;
Tracev((stderr, "inflate:       stored length %u\n",
state->length));
INITBITS();
state->mode = COPY;
  856         case COPY:
copy = state->length;
  858             if (copy) {
  859                 if (copy > have) copy = have;
  860                 if (copy > left) copy = left;
  861                 if (copy == 0) goto inf_leave;
zmemcpy(put, next, copy);
have -= copy;
next += copy;
left -= copy;
put += copy;
state->length -= copy;
  868                 break;
  869             }
Tracev((stderr, "inflate:       stored end\n"));
state->mode = TYPE;
  872             break;
  873         case TABLE:
NEEDBITS(14);
state->nlen = BITS(5) + 257;
DROPBITS(5);
state->ndist = BITS(5) + 1;
DROPBITS(5);
state->ncode = BITS(4) + 4;
DROPBITS(4);
  881 #ifndef PKZIP_BUG_WORKAROUND
  882             if (state->nlen > 286 || state->ndist > 30) {
  883 #ifdef SMALL  
strm->msg = "error";
  885 #else
strm->msg = (char *)"too many length or distance symbols";
  887 #endif
state->mode = BAD;
  889                 break;
  890             }
  891 #endif
Tracev((stderr, "inflate:       table sizes ok\n"));
state->have = 0;
state->mode = LENLENS;
  895         case LENLENS:
  896             while (state->have < state->ncode) {
NEEDBITS(3);
state->lens[order[state->have++]] = (unsigned short)BITS(3);
DROPBITS(3);
  900             }
  901             while (state->have < 19)
state->lens[order[state->have++]] = 0;
state->next = state->codes;
state->lencode = (code const FAR *)(state->next);
state->lenbits = 7;
ret = inflate_table(CODES, state->lens, 19, &(state->next),
  907                                 &(state->lenbits), state->work);
  908             if (ret) {
  909 #ifdef SMALL  
strm->msg = "error";
  911 #else
strm->msg = (char *)"invalid code lengths set";
  913 #endif
state->mode = BAD;
  915                 break;
  916             }
Tracev((stderr, "inflate:       code lengths ok\n"));
state->have = 0;
state->mode = CODELENS;
  920         case CODELENS:
  921             while (state->have < state->nlen + state->ndist) {
  922                 for (;;) {
this = state->lencode[BITS(state->lenbits)];
  924                     if ((unsigned)(this.bits) <= bits) break;
PULLBYTE();
  926                 }
  927                 if (this.val < 16) {
NEEDBITS(this.bits);
DROPBITS(this.bits);
state->lens[state->have++] = this.val;
  931                 }
  932                 else {
  933                     if (this.val == 16) {
NEEDBITS(this.bits + 2);
DROPBITS(this.bits);
  936                         if (state->have == 0) {
  937 #ifdef SMALL  
strm->msg = "error";
  939 #else
strm->msg = (char *)"invalid bit length repeat";
  941 #endif
state->mode = BAD;
  943                             break;
  944                         }
len = state->lens[state->have - 1];
copy = 3 + BITS(2);
DROPBITS(2);
  948                     }
  949                     else if (this.val == 17) {
NEEDBITS(this.bits + 3);
DROPBITS(this.bits);
len = 0;
copy = 3 + BITS(3);
DROPBITS(3);
  955                     }
  956                     else {
NEEDBITS(this.bits + 7);
DROPBITS(this.bits);
len = 0;
copy = 11 + BITS(7);
DROPBITS(7);
  962                     }
  963                     if (state->have + copy > state->nlen + state->ndist) {
  964 #ifdef SMALL  
strm->msg = "error";
  966 #else
strm->msg = (char *)"invalid bit length repeat";
  968 #endif
state->mode = BAD;
  970                         break;
  971                     }
  972                     while (copy--)
state->lens[state->have++] = (unsigned short)len;
  974                 }
  975             }
  977             /* handle error breaks in while */
  978             if (state->mode == BAD) break;
  980             /* build code tables */
state->next = state->codes;
state->lencode = (code const FAR *)(state->next);
state->lenbits = 9;
ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
  985                                 &(state->lenbits), state->work);
  986             if (ret) {
  987 #ifdef SMALL  
strm->msg = "error";
  989 #else
strm->msg = (char *)"invalid literal/lengths set";
  991 #endif
state->mode = BAD;
  993                 break;
  994             }
state->distcode = (code const FAR *)(state->next);
state->distbits = 6;
ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
  998                             &(state->next), &(state->distbits), state->work);
  999             if (ret) {
 1000 #ifdef SMALL  
strm->msg = "error";
 1002 #else
strm->msg = (char *)"invalid distances set";
 1004 #endif
state->mode = BAD;
 1006                 break;
 1007             }
Tracev((stderr, "inflate:       codes ok\n"));
state->mode = LEN;
 1010         case LEN:
 1011 #ifndef SLOW
 1012             if (have >= 6 && left >= 258) {
RESTORE();
inflate_fast(strm, out);
LOAD();
 1016                 break;
 1017             }
 1018 #endif
 1019             for (;;) {
this = state->lencode[BITS(state->lenbits)];
 1021                 if ((unsigned)(this.bits) <= bits) break;
PULLBYTE();
 1023             }
 1024             if (this.op && (this.op & 0xf0) == 0) {
last = this;
 1026                 for (;;) {
this = state->lencode[last.val +
 1028                             (BITS(last.bits + last.op) >> last.bits)];
 1029                     if ((unsigned)(last.bits + this.bits) <= bits) break;
PULLBYTE();
 1031                 }
DROPBITS(last.bits);
 1033             }
DROPBITS(this.bits);
state->length = (unsigned)this.val;
 1036             if ((int)(this.op) == 0) {
Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
 1038                         "inflate:         literal '%c'\n" :
 1039                         "inflate:         literal 0x%02x\n", this.val));
state->mode = LIT;
 1041                 break;
 1042             }
 1043             if (this.op & 32) {
Tracevv((stderr, "inflate:         end of block\n"));
state->mode = TYPE;
 1046                 break;
 1047             }
 1048             if (this.op & 64) {
 1049 #ifdef SMALL  
strm->msg = "error";
 1051 #else
strm->msg = (char *)"invalid literal/length code";
 1053 #endif
state->mode = BAD;
 1055                 break;
 1056             }
state->extra = (unsigned)(this.op) & 15;
state->mode = LENEXT;
 1059         case LENEXT:
 1060             if (state->extra) {
NEEDBITS(state->extra);
state->length += BITS(state->extra);
DROPBITS(state->extra);
 1064             }
Tracevv((stderr, "inflate:         length %u\n", state->length));
state->mode = DIST;
 1067         case DIST:
 1068             for (;;) {
this = state->distcode[BITS(state->distbits)];
 1070                 if ((unsigned)(this.bits) <= bits) break;
PULLBYTE();
 1072             }
 1073             if ((this.op & 0xf0) == 0) {
last = this;
 1075                 for (;;) {
this = state->distcode[last.val +
 1077                             (BITS(last.bits + last.op) >> last.bits)];
 1078                     if ((unsigned)(last.bits + this.bits) <= bits) break;
PULLBYTE();
 1080                 }
DROPBITS(last.bits);
 1082             }
DROPBITS(this.bits);
 1084             if (this.op & 64) {
 1085 #ifdef SMALL  
strm->msg = "error";
 1087 #else
strm->msg = (char *)"invalid distance code";
 1089 #endif
state->mode = BAD;
 1091                 break;
 1092             }
state->offset = (unsigned)this.val;
state->extra = (unsigned)(this.op) & 15;
state->mode = DISTEXT;
 1096         case DISTEXT:
 1097             if (state->extra) {
NEEDBITS(state->extra);
state->offset += BITS(state->extra);
DROPBITS(state->extra);
 1101             }
 1102 #ifdef INFLATE_STRICT
 1103             if (state->offset > state->dmax) {
strm->msg = (char *)"invalid distance too far back";
state->mode = BAD;
 1106                 break;
 1107             }
 1108 #endif
 1109             if (state->offset > state->whave + out - left) {
 1110 #ifdef SMALL  
strm->msg = "error";
 1112 #else
strm->msg = (char *)"invalid distance too far back";
 1114 #endif
state->mode = BAD;
 1116                 break;
 1117             }
Tracevv((stderr, "inflate:         distance %u\n", state->offset));
state->mode = MATCH;
 1120         case MATCH:
 1121             if (left == 0) goto inf_leave;
copy = out - left;
 1123             if (state->offset > copy) {         /* copy from window */
copy = state->offset - copy;
 1125                 if (copy > state->write) {
copy -= state->write;
from = state->window + (state->wsize - copy);
 1128                 }
 1129                 else
from = state->window + (state->write - copy);
 1131                 if (copy > state->length) copy = state->length;
 1132             }
 1133             else {                              /* copy from output */
from = put - state->offset;
copy = state->length;
 1136             }
 1137             if (copy > left) copy = left;
left -= copy;
state->length -= copy;
 1140             do {
 1141                 *put++ = *from++;
 1142             } while (--copy);
 1143             if (state->length == 0) state->mode = LEN;
 1144             break;
 1145         case LIT:
 1146             if (left == 0) goto inf_leave;
 1147             *put++ = (unsigned char)(state->length);
left--;
state->mode = LEN;
 1150             break;
 1151         case CHECK:
 1152             if (state->wrap) {
NEEDBITS(32);
out -= left;
strm->total_out += out;
state->total += out;
 1157                 if (out)
strm->adler = state->check =
UPDATE(state->check, put - out, out);
out = left;
 1161                 if ((
 1162 #ifdef GUNZIP
state->flags ? hold :
 1164 #endif
REVERSE(hold)) != state->check) {
 1166 #ifdef SMALL  
strm->msg = "error";
 1168 #else
strm->msg = (char *)"incorrect data check";
 1170 #endif
state->mode = BAD;
 1172                     break;
 1173                 }
INITBITS();
Tracev((stderr, "inflate:   check matches trailer\n"));
 1176             }
 1177 #ifdef GUNZIP
state->mode = LENGTH;
 1179         case LENGTH:
 1180             if (state->wrap && state->flags) {
NEEDBITS(32);
 1182                 if (hold != (state->total & 0xffffffffUL)) {
 1183 #ifdef SMALL  
strm->msg = "error";
 1185 #else
strm->msg = (char *)"incorrect length check";
 1187 #endif
state->mode = BAD;
 1189                     break;
 1190                 }
INITBITS();
Tracev((stderr, "inflate:   length matches trailer\n"));
 1193             }
 1194 #endif
state->mode = DONE;
 1196         case DONE:
ret = Z_STREAM_END;
 1198             goto inf_leave;
 1199         case BAD:
ret = Z_DATA_ERROR;
 1201             goto inf_leave;
 1202         case MEM:
 1203             return Z_MEM_ERROR;
 1204         case SYNC:
 1205         default:
 1206             return Z_STREAM_ERROR;
 1207         }
 1209     /*
 1210        Return from inflate(), updating the total counts and the check value.
 1211        If there was no progress during the inflate() call, return a buffer
 1212        error.  Call updatewindow() to create and/or update the window state.
 1213        Note: a memory error from inflate() is non-recoverable.
 1214      */
inf_leave:
RESTORE();
 1217     if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
 1218         if (updatewindow(strm, out)) {
state->mode = MEM;
 1220             return Z_MEM_ERROR;
 1221         }
in -= strm->avail_in;
out -= strm->avail_out;
strm->total_in += in;
strm->total_out += out;
state->total += out;
 1227     if (state->wrap && out)
strm->adler = state->check =
UPDATE(state->check, strm->next_out - out, out);
strm->data_type = state->bits + (state->last ? 64 : 0) +
 1231                       (state->mode == TYPE ? 128 : 0);
 1232     if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
ret = Z_BUF_ERROR;
 1234     return ret;
 1235 }
 1237 int ZEXPORT inflateEnd(strm)
z_streamp strm;
 1239 {
 1240     struct inflate_state FAR *state;
 1241     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
 1242         return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
 1244     if (state->window != Z_NULL) ZFREE(strm, state->window);
ZFREE(strm, strm->state);
strm->state = Z_NULL;
Tracev((stderr, "inflate: end\n"));
 1248     return Z_OK;
 1249 }
 1251 int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
z_streamp strm;
 1253 const Bytef *dictionary;
uInt dictLength;
 1255 {
 1256     struct inflate_state FAR *state;
 1257     unsigned long id;
 1259     /* check state */
 1260     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
 1262     if (state->wrap != 0 && state->mode != DICT)
 1263         return Z_STREAM_ERROR;
 1265     /* check for correct dictionary id */
 1266     if (state->mode == DICT) {
id = adler32(0L, Z_NULL, 0);
id = adler32(id, dictionary, dictLength);
 1269         if (id != state->check)
 1270             return Z_DATA_ERROR;
 1271     }
 1273     /* copy dictionary to window */
 1274     if (updatewindow(strm, strm->avail_out)) {
state->mode = MEM;
 1276         return Z_MEM_ERROR;
 1277     }
 1278     if (dictLength > state->wsize) {
zmemcpy(state->window, dictionary + dictLength - state->wsize,
state->wsize);
state->whave = state->wsize;
 1282     }
 1283     else {
zmemcpy(state->window + state->wsize - dictLength, dictionary,
dictLength);
state->whave = dictLength;
 1287     }
state->havedict = 1;
Tracev((stderr, "inflate:   dictionary set\n"));
 1290     return Z_OK;
 1291 }
 1293 int ZEXPORT inflateGetHeader(strm, head)
z_streamp strm;
gz_headerp head;
 1296 {
 1297     struct inflate_state FAR *state;
 1299     /* check state */
 1300     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
 1302     if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
 1304     /* save header structure */
state->head = head;
head->done = 0;
 1307     return Z_OK;
 1308 }
 1310 /*
 1311    Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
 1312    or when out of input.  When called, *have is the number of pattern bytes
 1313    found in order so far, in 0..3.  On return *have is updated to the new
 1314    state.  If on return *have equals four, then the pattern was found and the
 1315    return value is how many bytes were read including the last byte of the
 1316    pattern.  If *have is less than four, then the pattern has not been found
 1317    yet and the return value is len.  In the latter case, syncsearch() can be
 1318    called again with more data and the *have state.  *have is initialized to
 1319    zero for the first call.
 1320  */
local unsigned syncsearch(have, buf, len)
 1322 unsigned FAR *have;
 1323 unsigned char FAR *buf;
 1324 unsigned len;
 1325 {
 1326     unsigned got;
 1327     unsigned next;
got = *have;
next = 0;
 1331     while (next < len && got < 4) {
 1332         if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
got++;
 1334         else if (buf[next])
got = 0;
 1336         else
got = 4 - got;
next++;
 1339     }
 1340     *have = got;
 1341     return next;
 1342 }
 1344 int ZEXPORT inflateSync(strm)
z_streamp strm;
 1346 {
 1347     unsigned len;               /* number of bytes to look at or looked at */
 1348     unsigned long in, out;      /* temporary to save total_in and total_out */
 1349     unsigned char buf[4];       /* to restore bit buffer to byte string */
 1350     struct inflate_state FAR *state;
 1352     /* check parameters */
 1353     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
 1355     if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
 1357     /* if first time, start search in bit buffer */
 1358     if (state->mode != SYNC) {
state->mode = SYNC;
state->hold <<= state->bits & 7;
state->bits -= state->bits & 7;
len = 0;
 1363         while (state->bits >= 8) {
buf[len++] = (unsigned char)(state->hold);
state->hold >>= 8;
state->bits -= 8;
 1367         }
state->have = 0;
syncsearch(&(state->have), buf, len);
 1370     }
 1372     /* search available input */
len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
strm->avail_in -= len;
strm->next_in += len;
strm->total_in += len;
 1378     /* return no joy or set up to restart inflate() on a new block */
 1379     if (state->have != 4) return Z_DATA_ERROR;
in = strm->total_in;  out = strm->total_out;
inflateReset(strm);
strm->total_in = in;  strm->total_out = out;
state->mode = TYPE;
 1384     return Z_OK;
 1385 }
 1387 /*
 1388    Returns true if inflate is currently at the end of a block generated by
 1389    Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
 1390    implementation to provide an additional safety check. PPP uses
 1391    Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
 1392    block. When decompressing, PPP checks that at the end of input packet,
 1393    inflate is waiting for these length bytes.
 1394  */
 1395 int ZEXPORT inflateSyncPoint(strm)
z_streamp strm;
 1397 {
 1398     struct inflate_state FAR *state;
 1400     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
 1402     return state->mode == STORED && state->bits == 0;
 1403 }
 1405 int ZEXPORT inflateCopy(dest, source)
z_streamp dest;
z_streamp source;
 1408 {
 1409     struct inflate_state FAR *state;
 1410     struct inflate_state FAR *copy;
 1411     unsigned char FAR *window;
 1412     unsigned wsize;
 1414     /* check input */
 1415     if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
 1417         return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)source->state;
 1420     /* allocate space */
copy = (struct inflate_state FAR *)
ZALLOC(source, 1, sizeof(struct inflate_state));
 1423     if (copy == Z_NULL) return Z_MEM_ERROR;
window = Z_NULL;
 1425     if (state->window != Z_NULL) {
window = (unsigned char FAR *)
ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
 1428         if (window == Z_NULL) {
ZFREE(source, copy);
 1430             return Z_MEM_ERROR;
 1431         }
 1432     }
 1434     /* copy state */
zmemcpy(dest, source, sizeof(z_stream));
zmemcpy(copy, state, sizeof(struct inflate_state));
 1437     if (state->lencode >= state->codes &&
state->lencode <= state->codes + ENOUGH - 1) {
copy->lencode = copy->codes + (state->lencode - state->codes);
copy->distcode = copy->codes + (state->distcode - state->codes);
 1441     }
copy->next = copy->codes + (state->next - state->codes);
 1443     if (window != Z_NULL) {
wsize = 1U << state->wbits;
zmemcpy(window, state->window, wsize);
 1446     }
copy->window = window;
dest->state = (struct internal_state FAR *)copy;
 1449     return Z_OK;
 1450 }