inflate.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation. Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/* inflate.c -- zlib decompression
 * Copyright (C) 1995-2022 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
 * Change history:
 *
 * 1.2.beta0 24 Nov 2002
 * - First version -- complete rewrite of inflate to simplify code, avoid
 * creation of window when not needed, minimize use of window when it is
 * needed, make inffast.c even faster, implement gzip decoding, and to
 * improve code readability and style over the previous zlib inflate code
 *
 * 1.2.beta1 25 Nov 2002
 * - Use pointers for available input and output checking in inffast.c
 * - Remove input and output counters in inffast.c
 * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
 * - Remove unnecessary second byte pull from length extra in inffast.c
 * - Unroll direct copy to three copies per loop in inffast.c
 *
 * 1.2.beta2 4 Dec 2002
 * - Change external routine names to reduce potential conflicts
 * - Correct filename to inffixed.h for fixed tables in inflate.c
 * - Make hbuf[] unsigned char to match parameter type in inflate.c
 * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
 * to avoid negation problem on Alphas (64 bit) in inflate.c
 *
 * 1.2.beta3 22 Dec 2002
 * - Add comments on state->bits assertion in inffast.c
 * - Add comments on op field in inftrees.h
 * - Fix bug in reuse of allocated window after inflateReset()
 * - Remove bit fields--back to byte structure for speed
 * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
 * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
 * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
 * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
 * - Use local copies of stream next and avail values, as well as local bit
 * buffer and bit count in inflate()--for speed when inflate_fast() not used
 *
 * 1.2.beta4 1 Jan 2003
 * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
 * - Move a comment on output buffer sizes from inffast.c to inflate.c
 * - Add comments in inffast.c to introduce the inflate_fast() routine
 * - Rearrange window copies in inflate_fast() for speed and simplification
 * - Unroll last copy for window match in inflate_fast()
 * - Use local copies of window variables in inflate_fast() for speed
 * - Pull out common wnext == 0 case for speed in inflate_fast()
 * - Make op and len in inflate_fast() unsigned for consistency
 * - Add FAR to lcode and dcode declarations in inflate_fast()
 * - Simplified bad distance check in inflate_fast()
 * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
 * source file infback.c to provide a call-back interface to inflate for
 * programs like gzip and unzip -- uses window as output buffer to avoid
 * window copying
 *
 * 1.2.beta5 1 Jan 2003
 * - Improved inflateBack() interface to allow the caller to provide initial
 * input in strm.
 * - Fixed stored blocks bug in inflateBack()
 *
 * 1.2.beta6 4 Jan 2003
 * - Added comments in inffast.c on effectiveness of POSTINC
 * - Typecasting all around to reduce compiler warnings
 * - Changed loops from while (1) or do {} while (1) to for (;;), again to
 * make compilers happy
 * - Changed type of window in inflateBackInit() to unsigned char *
 *
 * 1.2.beta7 27 Jan 2003
 * - Changed many types to unsigned or unsigned short to avoid warnings
 * - Added inflateCopy() function
 *
 * 1.2.0 9 Mar 2003
 * - Changed inflateBack() interface to provide separate opaque descriptors
 * for the in() and out() functions
 * - Changed inflateBack() argument and in_func typedef to swap the length
 * and buffer address return values for the input function
 * - Check next_in and next_out for Z_NULL on entry to inflate()
 *
 * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
 */

#include"zutil.h"
#include"inftrees.h"
#include"inflate.h"
#include"inffast.h"

#ifdefMAKEFIXED
# ifndefBUILDFIXED
# defineBUILDFIXED
# endif
#endif

localintinflateStateCheck(z_streampstrm) {
structinflate_stateFAR*state;
if (strm==Z_NULL||
strm->zalloc== (alloc_func)0||strm->zfree== (free_func)0)
return1;
state= (structinflate_stateFAR*)strm->state;
if (state==Z_NULL||state->strm!=strm||
state->mode<HEAD||state->mode>SYNC)
return1;
return0;
}

intZEXPORTinflateResetKeep(z_streampstrm) {
structinflate_stateFAR*state;

if (inflateStateCheck(strm)) returnZ_STREAM_ERROR;
state= (structinflate_stateFAR*)strm->state;
strm->total_in=strm->total_out=state->total=0;
strm->msg=Z_NULL;
if (state->wrap) /* to support ill-conceived Java test suite */
strm->adler=state->wrap&1;
state->mode=HEAD;
state->last=0;
state->havedict=0;
state->flags=-1;
state->dmax=32768U;
state->head=Z_NULL;
state->hold=0;
state->bits=0;
state->lencode=state->distcode=state->next=state->codes;
state->sane=1;
state->back=-1;
Tracev((stderr, "inflate: reset\n"));
returnZ_OK;
}

intZEXPORTinflateReset(z_streampstrm) {
structinflate_stateFAR*state;

if (inflateStateCheck(strm)) returnZ_STREAM_ERROR;
state= (structinflate_stateFAR*)strm->state;
state->wsize=0;
state->whave=0;
state->wnext=0;
returninflateResetKeep(strm);
}

intZEXPORTinflateReset2(z_streampstrm, intwindowBits) {
intwrap;
structinflate_stateFAR*state;

/* get the state */
if (inflateStateCheck(strm)) returnZ_STREAM_ERROR;
state= (structinflate_stateFAR*)strm->state;

/* extract wrap request from windowBits parameter */
if (windowBits<0) {
if (windowBits<-15)
returnZ_STREAM_ERROR;
wrap=0;
windowBits=-windowBits;
 }
else {
wrap= (windowBits >> 4) +5;
#ifdefGUNZIP
if (windowBits<48)
windowBits &= 15;
#endif
 }

/* set number of window bits, free window if different */
if (windowBits&& (windowBits<8||windowBits>15))
returnZ_STREAM_ERROR;
if (state->window!=Z_NULL&&state->wbits!= (unsigned)windowBits) {
ZFREE(strm, state->window);
state->window=Z_NULL;
 }

/* update state and reset the rest of it */
state->wrap=wrap;
state->wbits= (unsigned)windowBits;
returninflateReset(strm);
}

intZEXPORTinflateInit2_(z_streampstrm, intwindowBits,
constchar*version, intstream_size) {
intret;
structinflate_stateFAR*state;

if (version==Z_NULL||version[0] !=ZLIB_VERSION[0] ||
stream_size!= (int)(sizeof(z_stream)))
returnZ_VERSION_ERROR;
if (strm==Z_NULL) returnZ_STREAM_ERROR;
strm->msg=Z_NULL; /* in case we return an error */
if (strm->zalloc== (alloc_func)0) {
#ifdefZ_SOLO
returnZ_STREAM_ERROR;
#else
strm->zalloc=zcalloc;
strm->opaque= (voidpf)0;
#endif
 }
if (strm->zfree== (free_func)0)
#ifdefZ_SOLO
returnZ_STREAM_ERROR;
#else
strm->zfree=zcfree;
#endif
state= (structinflate_stateFAR*)
ZALLOC(strm, 1, sizeof(structinflate_state));
if (state==Z_NULL) returnZ_MEM_ERROR;
Tracev((stderr, "inflate: allocated\n"));
strm->state= (structinternal_stateFAR*)state;
state->strm=strm;
state->window=Z_NULL;
state->mode=HEAD; /* to pass state test in inflateReset2() */
ret=inflateReset2(strm, windowBits);
if (ret!=Z_OK) {
ZFREE(strm, state);
strm->state=Z_NULL;
 }
returnret;
}

intZEXPORTinflateInit_(z_streampstrm, constchar*version,
intstream_size) {
returninflateInit2_(strm, DEF_WBITS, version, stream_size);
}

intZEXPORTinflatePrime(z_streampstrm, intbits, intvalue) {
structinflate_stateFAR*state;

if (inflateStateCheck(strm)) returnZ_STREAM_ERROR;
if (bits==0)
returnZ_OK;
state= (structinflate_stateFAR*)strm->state;
if (bits<0) {
state->hold=0;
state->bits=0;
returnZ_OK;
 }
if (bits>16||state->bits+ (uInt)bits>32) returnZ_STREAM_ERROR;
value &= (1L << bits) -1;
state->hold+= (unsigned)value << state->bits;
state->bits+= (uInt)bits;
returnZ_OK;
}

/*
 Return state with length and distance decoding tables and index sizes set to
 fixed code decoding. Normally this returns fixed tables from inffixed.h.
 If BUILDFIXED is defined, then instead this routine builds the tables the
 first time it's called, and returns those tables the first time and
 thereafter. This reduces the size of the code by about 2K bytes, in
 exchange for a little execution time. However, BUILDFIXED should not be
 used for threaded applications, since the rewriting of the tables and virgin
 may not be thread-safe.
 */
localvoidfixedtables(structinflate_stateFAR*state) {
#ifdefBUILDFIXED
staticintvirgin=1;
staticcode*lenfix, *distfix;
staticcodefixed[544];

/* build fixed huffman tables if first call (may not be thread safe) */
if (virgin) {
unsignedsym, bits;
staticcode*next;

/* literal/length table */
sym=0;
while (sym<144) state->lens[sym++] =8;
while (sym<256) state->lens[sym++] =9;
while (sym<280) state->lens[sym++] =7;
while (sym<288) state->lens[sym++] =8;
next=fixed;
lenfix=next;
bits=9;
inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);

/* distance table */
sym=0;
while (sym<32) state->lens[sym++] =5;
distfix=next;
bits=5;
inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);

/* do this just once */
virgin=0;
 }
#else/* !BUILDFIXED */
# include"inffixed.h"
#endif/* BUILDFIXED */
state->lencode=lenfix;
state->lenbits=9;
state->distcode=distfix;
state->distbits=5;
}

#ifdefMAKEFIXED
#include<stdio.h>

/*
 Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also
 defines BUILDFIXED, so the tables are built on the fly. makefixed() writes
 those tables to stdout, which would be piped to inffixed.h. A small program
 can simply call makefixed to do this:

 void makefixed(void);

 int main(void)
 {
 makefixed();
 return 0;
 }

 Then that can be linked with zlib built with MAKEFIXED defined and run:

 a.out > inffixed.h
 */
voidmakefixed(void)
{
unsignedlow, size;
structinflate_statestate;

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;
for (;;) {
if ((low % 7) ==0) printf("\n ");
printf("{%u,%u,%d}", (low&127) ==99 ? 64 : state.lencode[low].op,
state.lencode[low].bits, state.lencode[low].val);
if (++low==size) break;
putchar(',');
 }
puts("\n };");
size=1U << 5;
printf("\n static const code distfix[%u] = {", size);
low=0;
for (;;) {
if ((low % 6) ==0) printf("\n ");
printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
state.distcode[low].val);
if (++low==size) break;
putchar(',');
 }
puts("\n };");
}
#endif/* MAKEFIXED */

/*
 Update the window with the last wsize (normally 32K) bytes written before
 returning. If window does not exist yet, create it. This is only called
 when a window is already in use, or when output has been written during this
 inflate call, but the end of the deflate stream has not been reached yet.
 It is also called to create a window for dictionary data when a dictionary
 is loaded.

 Providing output buffers larger than 32K to inflate() should provide a speed
 advantage, since only the last 32K of output is copied to the sliding window
 upon return from inflate(), and since all distances after the first 32K of
 output will fall in the output data, making match copies simpler and faster.
 The advantage may be dependent on the size of the processor's data caches.
 */
localintupdatewindow(z_streampstrm, constBytef*end, unsignedcopy) {
structinflate_stateFAR*state;
unsigneddist;

state= (structinflate_stateFAR*)strm->state;

/* if it hasn't been done already, allocate space for the window */
if (state->window==Z_NULL) {
state->window= (unsigned charFAR*)
ZALLOC(strm, 1U << state->wbits,
sizeof(unsigned char));
if (state->window==Z_NULL) return1;
 }

/* if window not in use yet, initialize */
if (state->wsize==0) {
state->wsize=1U << state->wbits;
state->wnext=0;
state->whave=0;
 }

/* copy state->wsize or less output bytes into the circular window */
if (copy >= state->wsize) {
zmemcpy(state->window, end-state->wsize, state->wsize);
state->wnext=0;
state->whave=state->wsize;
 }
else {
dist=state->wsize-state->wnext;
if (dist>copy) dist=copy;
zmemcpy(state->window+state->wnext, end-copy, dist);
copy-=dist;
if (copy) {
zmemcpy(state->window, end-copy, copy);
state->wnext=copy;
state->whave=state->wsize;
 }
else {
state->wnext+=dist;
if (state->wnext==state->wsize) state->wnext=0;
if (state->whave<state->wsize) state->whave+=dist;
 }
 }
return0;
}

/* Macros for inflate(): */

/* check function to use adler32() for zlib or crc32() for gzip */
#ifdefGUNZIP
# defineUPDATE_CHECK(check, buf, len) \
 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
#else
# defineUPDATE_CHECK(check, buf, len) adler32(check, buf, len)
#endif

/* check macros for header crc */
#ifdefGUNZIP
# defineCRC2(check, word) \
 do { \
 hbuf[0] = (unsigned char)(word); \
 hbuf[1] = (unsigned char)((word) >> 8); \
 check = crc32(check, hbuf, 2); \
 } while (0)

# defineCRC4(check, word) \
 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); \
 } while (0)
#endif

/* Load registers with state in inflate() for speed */
#defineLOAD() \
 do { \
 put = strm->next_out; \
 left = strm->avail_out; \
 next = strm->next_in; \
 have = strm->avail_in; \
 hold = state->hold; \
 bits = state->bits; \
 } while (0)

/* Restore state from registers in inflate() */
#defineRESTORE() \
 do { \
 strm->next_out = put; \
 strm->avail_out = left; \
 strm->next_in = next; \
 strm->avail_in = have; \
 state->hold = hold; \
 state->bits = bits; \
 } while (0)

/* Clear the input bit accumulator */
#defineINITBITS() \
 do { \
 hold = 0; \
 bits = 0; \
 } while (0)

/* Get a byte of input into the bit accumulator, or return from inflate()
 if there is no input available. */
#definePULLBYTE() \
 do { \
 if (have == 0) goto inf_leave; \
 have--; \
 hold += (unsigned long)(*next++) << bits; \
 bits += 8; \
 } while (0)

/* Assure that there are at least n bits in the bit accumulator. If there is
 not enough available input to do that, then return from inflate(). */
#defineNEEDBITS(n) \
 do { \
 while (bits < (unsigned)(n)) \
 PULLBYTE(); \
 } while (0)

/* Return the low n bits of the bit accumulator (n < 16) */
#defineBITS(n) \
 ((unsigned)hold & ((1U << (n)) - 1))

/* Remove n bits from the bit accumulator */
#defineDROPBITS(n) \
 do { \
 hold >>= (n); \
 bits -= (unsigned)(n); \
 } while (0)

/* Remove zero to seven bits as needed to go to a byte boundary */
#defineBYTEBITS() \
 do { \
 hold >>= bits & 7; \
 bits -= bits & 7; \
 } while (0)

/*
 inflate() uses a state machine to process as much input data and generate as
 much output data as possible before returning. The state machine is
 structured roughly as follows:

 for (;;) switch (state) {
 ...
 case STATEn:
 if (not enough input data or output space to make progress)
 return;
 ... make progress ...
 state = STATEm;
 break;
 ...
 }

 so when inflate() is called again, the same case is attempted again, and
 if the appropriate resources are provided, the machine proceeds to the
 next state. The NEEDBITS() macro is usually the way the state evaluates
 whether it can proceed or should return. NEEDBITS() does the return if
 the requested bits are not available. The typical use of the BITS macros
 is:

 NEEDBITS(n);
 ... do something with BITS(n) ...
 DROPBITS(n);

 where NEEDBITS(n) either returns from inflate() if there isn't enough
 input left to load n bits into the accumulator, or it continues. BITS(n)
 gives the low n bits in the accumulator. When done, DROPBITS(n) drops
 the low n bits off the accumulator. INITBITS() clears the accumulator
 and sets the number of available bits to zero. BYTEBITS() discards just
 enough bits to put the accumulator on a byte boundary. After BYTEBITS()
 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.

 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
 if there is no input available. The decoding of variable length codes uses
 PULLBYTE() directly in order to pull just enough bytes to decode the next
 code, and no more.

 Some states loop until they get enough input, making sure that enough
 state information is maintained to continue the loop where it left off
 if NEEDBITS() returns in the loop. For example, want, need, and keep
 would all have to actually be part of the saved state in case NEEDBITS()
 returns:

 case STATEw:
 while (want < need) {
 NEEDBITS(n);
 keep[want++] = BITS(n);
 DROPBITS(n);
 }
 state = STATEx;
 case STATEx:

 As shown above, if the next state is also the next case, then the break
 is omitted.

 A state may also return if there is not enough output space available to
 complete that state. Those states are copying stored data, writing a
 literal byte, and copying a matching string.

 When returning, a "goto inf_leave" is used to update the total counters,
 update the check value, and determine whether any progress has been made
 during that inflate() call in order to return the proper return code.
 Progress is defined as a change in either strm->avail_in or strm->avail_out.
 When there is a window, goto inf_leave will update the window with the last
 output written. If a goto inf_leave occurs in the middle of decompression
 and there is no window currently, goto inf_leave will create one and copy
 output to the window for the next call of inflate().

 In this implementation, the flush parameter of inflate() only affects the
 return code (per zlib.h). inflate() always writes as much as possible to
 strm->next_out, given the space available and the provided input--the effect
 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
 the allocation of and copying into a sliding window until necessary, which
 provides the effect documented in zlib.h for Z_FINISH when the entire input
 stream available. So the only thing the flush parameter actually does is:
 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
 will return Z_BUF_ERROR if it has not reached the end of the stream.
 */

intZEXPORTinflate(z_streampstrm, intflush) {
structinflate_stateFAR*state;
z_const unsignedcharFAR*next; /* next input */
unsigned charFAR*put; /* next output */
unsignedhave, left; /* available input and output */
unsigned longhold; /* bit buffer */
unsignedbits; /* bits in bit buffer */
unsignedin, out; /* save starting available input and output */
unsignedcopy; /* number of stored or match bytes to copy */
unsigned charFAR*from; /* where to copy match bytes from */
codehere; /* current decoding table entry */
codelast; /* parent table entry */
unsignedlen; /* length to copy for repeats, bits to drop */
intret; /* return code */
#ifdefGUNZIP
unsigned charhbuf[4]; /* buffer for gzip header crc calculation */
#endif
staticconstunsigned shortorder[19] =/* permutation of code lengths */
 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};

if (inflateStateCheck(strm) ||strm->next_out==Z_NULL||
 (strm->next_in==Z_NULL&&strm->avail_in!=0))
returnZ_STREAM_ERROR;

state= (structinflate_stateFAR*)strm->state;
if (state->mode==TYPE) state->mode=TYPEDO; /* skip check */
LOAD();
in=have;
out=left;
ret=Z_OK;
for (;;)
switch (state->mode) {
caseHEAD:
if (state->wrap==0) {
state->mode=TYPEDO;
break;
 }
NEEDBITS(16);
#ifdefGUNZIP
if ((state->wrap&2) &&hold==0x8b1f) { /* gzip header */
if (state->wbits==0)
state->wbits=15;
state->check=crc32(0L, Z_NULL, 0);
CRC2(state->check, hold);
INITBITS();
state->mode=FLAGS;
break;
 }
if (state->head!=Z_NULL)
state->head->done=-1;
if (!(state->wrap&1) ||/* check if zlib header allowed */
#else
if (
#endif
 ((BITS(8) << 8) + (hold >> 8)) % 31) {
strm->msg= (char*)"incorrect header check";
state->mode=BAD;
break;
 }
if (BITS(4) !=Z_DEFLATED) {
strm->msg= (char*)"unknown compression method";
state->mode=BAD;
break;
 }
DROPBITS(4);
len=BITS(4) +8;
if (state->wbits==0)
state->wbits=len;
if (len>15||len>state->wbits) {
strm->msg= (char*)"invalid window size";
state->mode=BAD;
break;
 }
state->dmax=1U << len;
state->flags=0; /* indicate zlib header */
Tracev((stderr, "inflate: zlib header ok\n"));
strm->adler=state->check=adler32(0L, Z_NULL, 0);
state->mode=hold&0x200 ? DICTID : TYPE;
INITBITS();
break;
#ifdefGUNZIP
caseFLAGS:
NEEDBITS(16);
state->flags= (int)(hold);
if ((state->flags&0xff) !=Z_DEFLATED) {
strm->msg= (char*)"unknown compression method";
state->mode=BAD;
break;
 }
if (state->flags&0xe000) {
strm->msg= (char*)"unknown header flags set";
state->mode=BAD;
break;
 }
if (state->head!=Z_NULL)
state->head->text= (int)((hold >> 8) &1);
if ((state->flags&0x0200) && (state->wrap&4))
CRC2(state->check, hold);
INITBITS();
state->mode=TIME;
/* fallthrough */
caseTIME:
NEEDBITS(32);
if (state->head!=Z_NULL)
state->head->time=hold;
if ((state->flags&0x0200) && (state->wrap&4))
CRC4(state->check, hold);
INITBITS();
state->mode=OS;
/* fallthrough */
caseOS:
NEEDBITS(16);
if (state->head!=Z_NULL) {
state->head->xflags= (int)(hold&0xff);
state->head->os= (int)(hold >> 8);
 }
if ((state->flags&0x0200) && (state->wrap&4))
CRC2(state->check, hold);
INITBITS();
state->mode=EXLEN;
/* fallthrough */
caseEXLEN:
if (state->flags&0x0400) {
NEEDBITS(16);
state->length= (unsigned)(hold);
if (state->head!=Z_NULL)
state->head->extra_len= (unsigned)hold;
if ((state->flags&0x0200) && (state->wrap&4))
CRC2(state->check, hold);
INITBITS();
 }
elseif (state->head!=Z_NULL)
state->head->extra=Z_NULL;
state->mode=EXTRA;
/* fallthrough */
caseEXTRA:
if (state->flags&0x0400) {
copy=state->length;
if (copy>have) copy=have;
if (copy) {
if (state->head!=Z_NULL&&
state->head->extra!=Z_NULL&&
 (len=state->head->extra_len-state->length) <
state->head->extra_max) {
zmemcpy(state->head->extra+len, next,
len+copy>state->head->extra_max ?
state->head->extra_max-len : copy);
 }
if ((state->flags&0x0200) && (state->wrap&4))
state->check=crc32(state->check, next, copy);
have-=copy;
next+=copy;
state->length-=copy;
 }
if (state->length) goto inf_leave;
 }
state->length=0;
state->mode=NAME;
/* fallthrough */
caseNAME:
if (state->flags&0x0800) {
if (have==0) goto inf_leave;
copy=0;
do {
len= (unsigned)(next[copy++]);
if (state->head!=Z_NULL&&
state->head->name!=Z_NULL&&
state->length<state->head->name_max)
state->head->name[state->length++] = (Bytef)len;
 } while (len&&copy<have);
if ((state->flags&0x0200) && (state->wrap&4))
state->check=crc32(state->check, next, copy);
have-=copy;
next+=copy;
if (len) goto inf_leave;
 }
elseif (state->head!=Z_NULL)
state->head->name=Z_NULL;
state->length=0;
state->mode=COMMENT;
/* fallthrough */
caseCOMMENT:
if (state->flags&0x1000) {
if (have==0) goto inf_leave;
copy=0;
do {
len= (unsigned)(next[copy++]);
if (state->head!=Z_NULL&&
state->head->comment!=Z_NULL&&
state->length<state->head->comm_max)
state->head->comment[state->length++] = (Bytef)len;
 } while (len&&copy<have);
if ((state->flags&0x0200) && (state->wrap&4))
state->check=crc32(state->check, next, copy);
have-=copy;
next+=copy;
if (len) goto inf_leave;
 }
elseif (state->head!=Z_NULL)
state->head->comment=Z_NULL;
state->mode=HCRC;
/* fallthrough */
caseHCRC:
if (state->flags&0x0200) {
NEEDBITS(16);
if ((state->wrap&4) &&hold!= (state->check&0xffff)) {
strm->msg= (char*)"header crc mismatch";
state->mode=BAD;
break;
 }
INITBITS();
 }
if (state->head!=Z_NULL) {
state->head->hcrc= (int)((state->flags >> 9) &1);
state->head->done=1;
 }
strm->adler=state->check=crc32(0L, Z_NULL, 0);
state->mode=TYPE;
break;
#endif
caseDICTID:
NEEDBITS(32);
strm->adler=state->check=ZSWAP32(hold);
INITBITS();
state->mode=DICT;
/* fallthrough */
caseDICT:
if (state->havedict==0) {
RESTORE();
returnZ_NEED_DICT;
 }
strm->adler=state->check=adler32(0L, Z_NULL, 0);
state->mode=TYPE;
/* fallthrough */
caseTYPE:
if (flush==Z_BLOCK||flush==Z_TREES) goto inf_leave;
/* fallthrough */
caseTYPEDO:
if (state->last) {
BYTEBITS();
state->mode=CHECK;
break;
 }
NEEDBITS(3);
state->last=BITS(1);
DROPBITS(1);
switch (BITS(2)) {
case0: /* stored block */
Tracev((stderr, "inflate: stored block%s\n",
state->last ? " (last)" : ""));
state->mode=STORED;
break;
case1: /* fixed block */
fixedtables(state);
Tracev((stderr, "inflate: fixed codes block%s\n",
state->last ? " (last)" : ""));
state->mode=LEN_; /* decode codes */
if (flush==Z_TREES) {
DROPBITS(2);
 goto inf_leave;
 }
break;
case2: /* dynamic block */
Tracev((stderr, "inflate: dynamic codes block%s\n",
state->last ? " (last)" : ""));
state->mode=TABLE;
break;
case3:
strm->msg= (char*)"invalid block type";
state->mode=BAD;
 }
DROPBITS(2);
break;
caseSTORED:
BYTEBITS(); /* go to byte boundary */
NEEDBITS(32);
if ((hold&0xffff) != ((hold >> 16) ^ 0xffff)) {
strm->msg= (char*)"invalid stored block lengths";
state->mode=BAD;
break;
 }
state->length= (unsigned)hold&0xffff;
Tracev((stderr, "inflate: stored length %u\n",
state->length));
INITBITS();
state->mode=COPY_;
if (flush==Z_TREES) goto inf_leave;
/* fallthrough */
caseCOPY_:
state->mode=COPY;
/* fallthrough */
caseCOPY:
copy=state->length;
if (copy) {
if (copy>have) copy=have;
if (copy>left) copy=left;
if (copy==0) goto inf_leave;
zmemcpy(put, next, copy);
have-=copy;
next+=copy;
left-=copy;
put+=copy;
state->length-=copy;
break;
 }
Tracev((stderr, "inflate: stored end\n"));
state->mode=TYPE;
break;
caseTABLE:
NEEDBITS(14);
state->nlen=BITS(5) +257;
DROPBITS(5);
state->ndist=BITS(5) +1;
DROPBITS(5);
state->ncode=BITS(4) +4;
DROPBITS(4);
#ifndefPKZIP_BUG_WORKAROUND
if (state->nlen>286||state->ndist>30) {
strm->msg= (char*)"too many length or distance symbols";
state->mode=BAD;
break;
 }
#endif
Tracev((stderr, "inflate: table sizes ok\n"));
state->have=0;
state->mode=LENLENS;
/* fallthrough */
caseLENLENS:
while (state->have<state->ncode) {
NEEDBITS(3);
state->lens[order[state->have++]] = (unsigned short)BITS(3);
DROPBITS(3);
 }
while (state->have<19)
state->lens[order[state->have++]] =0;
state->next=state->codes;
state->lencode= (constcodeFAR*)(state->next);
state->lenbits=7;
ret=inflate_table(CODES, state->lens, 19, &(state->next),
&(state->lenbits), state->work);
if (ret) {
strm->msg= (char*)"invalid code lengths set";
state->mode=BAD;
break;
 }
Tracev((stderr, "inflate: code lengths ok\n"));
state->have=0;
state->mode=CODELENS;
/* fallthrough */
caseCODELENS:
while (state->have<state->nlen+state->ndist) {
for (;;) {
here=state->lencode[BITS(state->lenbits)];
if ((unsigned)(here.bits) <= bits) break;
PULLBYTE();
 }
if (here.val<16) {
DROPBITS(here.bits);
state->lens[state->have++] =here.val;
 }
else {
if (here.val==16) {
NEEDBITS(here.bits+2);
DROPBITS(here.bits);
if (state->have==0) {
strm->msg= (char*)"invalid bit length repeat";
state->mode=BAD;
break;
 }
len=state->lens[state->have-1];
copy=3+BITS(2);
DROPBITS(2);
 }
elseif (here.val==17) {
NEEDBITS(here.bits+3);
DROPBITS(here.bits);
len=0;
copy=3+BITS(3);
DROPBITS(3);
 }
else {
NEEDBITS(here.bits+7);
DROPBITS(here.bits);
len=0;
copy=11+BITS(7);
DROPBITS(7);
 }