wpkg test coverage results

Coverage test results of the Windows Packager by Made to Order Software Corporation.

LCOV - code coverage report
Current view: top level - zlib - inflate.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 379 676 56.1 %
Date: 2014-08-22 Functions: 8 18 44.4 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.9

The wpkg tool is an open source tool created by Made to Order Software Corporation.