inflate.c

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