LCOV - code coverage report
Current view: directory - modules/zlib/src - inflate.c (source / functions) Found Hit Coverage
Test: app.info Lines: 665 322 48.4 %
Date: 2012-06-02 Functions: 17 8 47.1 %

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

Generated by: LCOV version 1.7