zlib/inflate.c

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