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 += (unsigned)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                 if (state->wbits == 0)
 649                     state->wbits = 15;
 650                 state->check = crc32(0L, Z_NULL, 0);
 651                 CRC2(state->check, hold);
 652                 INITBITS();
 653                 state->mode = FLAGS;
 654                 break;
 655             }
 656             state->flags = 0;           /* expect zlib header */
 657             if (state->head != Z_NULL)
 658                 state->head->done = -1;
 659             if (!(state->wrap & 1) ||   /* check if zlib header allowed */
 660 #else
 661             if (
 662 #endif
 663                 ((BITS(8) << 8) + (hold >> 8)) % 31) {
 664                 strm->msg = (char *)"incorrect header check";
 665                 state->mode = BAD;
 666                 break;
 667             }
 668             if (BITS(4) != Z_DEFLATED) {
 669                 strm->msg = (char *)"unknown compression method";
 670                 state->mode = BAD;
 671                 break;
 672             }
 673             DROPBITS(4);
 674             len = BITS(4) + 8;
 675             if (state->wbits == 0)
 676                 state->wbits = len;
 677             if (len > 15 || len > state->wbits) {
 678                 strm->msg = (char *)"invalid window size";
 679                 state->mode = BAD;
 680                 break;
 681             }
 682             state->dmax = 1U << len;
 683             Tracev((stderr, "inflate:   zlib header ok\n"));
 684             strm->adler = state->check = adler32(0L, Z_NULL, 0);
 685             state->mode = hold & 0x200 ? DICTID : TYPE;
 686             INITBITS();
 687             break;
 688 #ifdef GUNZIP
 689         case FLAGS:
 690             NEEDBITS(16);
 691             state->flags = (int)(hold);
 692             if ((state->flags & 0xff) != Z_DEFLATED) {
 693                 strm->msg = (char *)"unknown compression method";
 694                 state->mode = BAD;
 695                 break;
 696             }
 697             if (state->flags & 0xe000) {
 698                 strm->msg = (char *)"unknown header flags set";
 699                 state->mode = BAD;
 700                 break;
 701             }
 702             if (state->head != Z_NULL)
 703                 state->head->text = (int)((hold >> 8) & 1);
 704             if (state->flags & 0x0200) CRC2(state->check, hold);
 705             INITBITS();
 706             state->mode = TIME;
 707         case TIME:
 708             NEEDBITS(32);
 709             if (state->head != Z_NULL)
 710                 state->head->time = hold;
 711             if (state->flags & 0x0200) CRC4(state->check, hold);
 712             INITBITS();
 713             state->mode = OS;
 714         case OS:
 715             NEEDBITS(16);
 716             if (state->head != Z_NULL) {
 717                 state->head->xflags = (int)(hold & 0xff);
 718                 state->head->os = (int)(hold >> 8);
 719             }
 720             if (state->flags & 0x0200) CRC2(state->check, hold);
 721             INITBITS();
 722             state->mode = EXLEN;
 723         case EXLEN:
 724             if (state->flags & 0x0400) {
 725                 NEEDBITS(16);
 726                 state->length = (unsigned)(hold);
 727                 if (state->head != Z_NULL)
 728                     state->head->extra_len = (unsigned)hold;
 729                 if (state->flags & 0x0200) CRC2(state->check, hold);
 730                 INITBITS();
 731             }
 732             else if (state->head != Z_NULL)
 733                 state->head->extra = Z_NULL;
 734             state->mode = EXTRA;
 735         case EXTRA:
 736             if (state->flags & 0x0400) {
 737                 copy = state->length;
 738                 if (copy > have) copy = have;
 739                 if (copy) {
 740                     if (state->head != Z_NULL &&
 741                         state->head->extra != Z_NULL) {
 742                         len = state->head->extra_len - state->length;
 743                         zmemcpy(state->head->extra + len, next,
 744                                 len + copy > state->head->extra_max ?
 745                                 state->head->extra_max - len : copy);
 746                     }
 747                     if (state->flags & 0x0200)
 748                         state->check = crc32(state->check, next, copy);
 749                     have -= copy;
 750                     next += copy;
 751                     state->length -= copy;
 752                 }
 753                 if (state->length) goto inf_leave;
 754             }
 755             state->length = 0;
 756             state->mode = NAME;
 757         case NAME:
 758             if (state->flags & 0x0800) {
 759                 if (have == 0) goto inf_leave;
 760                 copy = 0;
 761                 do {
 762                     len = (unsigned)(next[copy++]);
 763                     if (state->head != Z_NULL &&
 764                             state->head->name != Z_NULL &&
 765                             state->length < state->head->name_max)
 766                         state->head->name[state->length++] = len;
 767                 } while (len && copy < have);
 768                 if (state->flags & 0x0200)
 769                     state->check = crc32(state->check, next, copy);
 770                 have -= copy;
 771                 next += copy;
 772                 if (len) goto inf_leave;
 773             }
 774             else if (state->head != Z_NULL)
 775                 state->head->name = Z_NULL;
 776             state->length = 0;
 777             state->mode = COMMENT;
 778         case COMMENT:
 779             if (state->flags & 0x1000) {
 780                 if (have == 0) goto inf_leave;
 781                 copy = 0;
 782                 do {
 783                     len = (unsigned)(next[copy++]);
 784                     if (state->head != Z_NULL &&
 785                             state->head->comment != Z_NULL &&
 786                             state->length < state->head->comm_max)
 787                         state->head->comment[state->length++] = len;
 788                 } while (len && copy < have);
 789                 if (state->flags & 0x0200)
 790                     state->check = crc32(state->check, next, copy);
 791                 have -= copy;
 792                 next += copy;
 793                 if (len) goto inf_leave;
 794             }
 795             else if (state->head != Z_NULL)
 796                 state->head->comment = Z_NULL;
 797             state->mode = HCRC;
 798         case HCRC:
 799             if (state->flags & 0x0200) {
 800                 NEEDBITS(16);
 801                 if (hold != (state->check & 0xffff)) {
 802                     strm->msg = (char *)"header crc mismatch";
 803                     state->mode = BAD;
 804                     break;
 805                 }
 806                 INITBITS();
 807             }
 808             if (state->head != Z_NULL) {
 809                 state->head->hcrc = (int)((state->flags >> 9) & 1);
 810                 state->head->done = 1;
 811             }
 812             strm->adler = state->check = crc32(0L, Z_NULL, 0);
 813             state->mode = TYPE;
 814             break;
 815 #endif
 816         case DICTID:
 817             NEEDBITS(32);
 818             strm->adler = state->check = ZSWAP32(hold);
 819             INITBITS();
 820             state->mode = DICT;
 821         case DICT:
 822             if (state->havedict == 0) {
 823                 RESTORE();
 824                 return Z_NEED_DICT;
 825             }
 826             strm->adler = state->check = adler32(0L, Z_NULL, 0);
 827             state->mode = TYPE;
 828         case TYPE:
 829             if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
 830         case TYPEDO:
 831             if (state->last) {
 832                 BYTEBITS();
 833                 state->mode = CHECK;
 834                 break;
 835             }
 836             NEEDBITS(3);
 837             state->last = BITS(1);
 838             DROPBITS(1);
 839             switch (BITS(2)) {
 840             case 0:                             /* stored block */
 841                 Tracev((stderr, "inflate:     stored block%s\n",
 842                         state->last ? " (last)" : ""));
 843                 state->mode = STORED;
 844                 break;
 845             case 1:                             /* fixed block */
 846                 fixedtables(state);
 847                 Tracev((stderr, "inflate:     fixed codes block%s\n",
 848                         state->last ? " (last)" : ""));
 849                 state->mode = LEN_;             /* decode codes */
 850                 if (flush == Z_TREES) {
 851                     DROPBITS(2);
 852                     goto inf_leave;
 853                 }
 854                 break;
 855             case 2:                             /* dynamic block */
 856                 Tracev((stderr, "inflate:     dynamic codes block%s\n",
 857                         state->last ? " (last)" : ""));
 858                 state->mode = TABLE;
 859                 break;
 860             case 3:
 861                 strm->msg = (char *)"invalid block type";
 862                 state->mode = BAD;
 863             }
 864             DROPBITS(2);
 865             break;
 866         case STORED:
 867             BYTEBITS();                         /* go to byte boundary */
 868             NEEDBITS(32);
 869             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
 870                 strm->msg = (char *)"invalid stored block lengths";
 871                 state->mode = BAD;
 872                 break;
 873             }
 874             state->length = (unsigned)hold & 0xffff;
 875             Tracev((stderr, "inflate:       stored length %u\n",
 876                     state->length));
 877             INITBITS();
 878             state->mode = COPY_;
 879             if (flush == Z_TREES) goto inf_leave;
 880         case COPY_:
 881             state->mode = COPY;
 882         case COPY:
 883             copy = state->length;
 884             if (copy) {
 885                 if (copy > have) copy = have;
 886                 if (copy > left) copy = left;
 887                 if (copy == 0) goto inf_leave;
 888                 zmemcpy(put, next, copy);
 889                 have -= copy;
 890                 next += copy;
 891                 left -= copy;
 892                 put += copy;
 893                 state->length -= copy;
 894                 break;
 895             }
 896             Tracev((stderr, "inflate:       stored end\n"));
 897             state->mode = TYPE;
 898             break;
 899         case TABLE:
 900             NEEDBITS(14);
 901             state->nlen = BITS(5) + 257;
 902             DROPBITS(5);
 903             state->ndist = BITS(5) + 1;
 904             DROPBITS(5);
 905             state->ncode = BITS(4) + 4;
 906             DROPBITS(4);
 907 #ifndef PKZIP_BUG_WORKAROUND
 908             if (state->nlen > 286 || state->ndist > 30) {
 909                 strm->msg = (char *)"too many length or distance symbols";
 910                 state->mode = BAD;
 911                 break;
 912             }
 913 #endif
 914             Tracev((stderr, "inflate:       table sizes ok\n"));
 915             state->have = 0;
 916             state->mode = LENLENS;
 917         case LENLENS:
 918             while (state->have < state->ncode) {
 919                 NEEDBITS(3);
 920                 state->lens[order[state->have++]] = (unsigned short)BITS(3);
 921                 DROPBITS(3);
 922             }
 923             while (state->have < 19)
 924                 state->lens[order[state->have++]] = 0;
 925             state->next = state->codes;
 926             state->lencode = (const code FAR *)(state->next);
 927             state->lenbits = 7;
 928             ret = inflate_table(CODES, state->lens, 19, &(state->next),
 929                                 &(state->lenbits), state->work);
 930             if (ret) {
 931                 strm->msg = (char *)"invalid code lengths set";
 932                 state->mode = BAD;
 933                 break;
 934             }
 935             Tracev((stderr, "inflate:       code lengths ok\n"));
 936             state->have = 0;
 937             state->mode = CODELENS;
 938         case CODELENS:
 939             while (state->have < state->nlen + state->ndist) {
 940                 for (;;) {
 941                     here = state->lencode[BITS(state->lenbits)];
 942                     if ((unsigned)(here.bits) <= bits) break;
 943                     PULLBYTE();
 944                 }
 945                 if (here.val < 16) {
 946                     DROPBITS(here.bits);
 947                     state->lens[state->have++] = here.val;
 948                 }
 949                 else {
 950                     if (here.val == 16) {
 951                         NEEDBITS(here.bits + 2);
 952                         DROPBITS(here.bits);
 953                         if (state->have == 0) {
 954                             strm->msg = (char *)"invalid bit length repeat";
 955                             state->mode = BAD;
 956                             break;
 957                         }
 958                         len = state->lens[state->have - 1];
 959                         copy = 3 + BITS(2);
 960                         DROPBITS(2);
 961                     }
 962                     else if (here.val == 17) {
 963                         NEEDBITS(here.bits + 3);
 964                         DROPBITS(here.bits);
 965                         len = 0;
 966                         copy = 3 + BITS(3);
 967                         DROPBITS(3);
 968                     }
 969                     else {
 970                         NEEDBITS(here.bits + 7);
 971                         DROPBITS(here.bits);
 972                         len = 0;
 973                         copy = 11 + BITS(7);
 974                         DROPBITS(7);
 975                     }
 976                     if (state->have + copy > state->nlen + state->ndist) {
 977                         strm->msg = (char *)"invalid bit length repeat";
 978                         state->mode = BAD;
 979                         break;
 980                     }
 981                     while (copy--)
 982                         state->lens[state->have++] = (unsigned short)len;
 983                 }
 984             }
 985
 986             /* handle error breaks in while */
 987             if (state->mode == BAD) break;
 988
 989             /* check for end-of-block code (better have one) */
 990             if (state->lens[256] == 0) {
 991                 strm->msg = (char *)"invalid code -- missing end-of-block";
 992                 state->mode = BAD;
 993                 break;
 994             }
 995
 996             /* build code tables -- note: do not change the lenbits or distbits
 997                values here (9 and 6) without reading the comments in inftrees.h
 998                concerning the ENOUGH constants, which depend on those values */
 999             state->next = state->codes;
1000             state->lencode = (const code FAR *)(state->next);
1001             state->lenbits = 9;
1002             ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1003                                 &(state->lenbits), state->work);
1004             if (ret) {
1005                 strm->msg = (char *)"invalid literal/lengths set";
1006                 state->mode = BAD;
1007                 break;
1008             }
1009             state->distcode = (const code FAR *)(state->next);
1010             state->distbits = 6;
1011             ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1012                             &(state->next), &(state->distbits), state->work);
1013             if (ret) {
1014                 strm->msg = (char *)"invalid distances set";
1015                 state->mode = BAD;
1016                 break;
1017             }
1018             Tracev((stderr, "inflate:       codes ok\n"));
1019             state->mode = LEN_;
1020             if (flush == Z_TREES) goto inf_leave;
1021         case LEN_:
1022             state->mode = LEN;
1023         case LEN:
1024             if (have >= 6 && left >= 258) {
1025                 RESTORE();
1026                 inflate_fast(strm, out);
1027                 LOAD();
1028                 if (state->mode == TYPE)
1029                     state->back = -1;
1030                 break;
1031             }
1032             state->back = 0;
1033             for (;;) {
1034                 here = state->lencode[BITS(state->lenbits)];
1035                 if ((unsigned)(here.bits) <= bits) break;
1036                 PULLBYTE();
1037             }
1038             if (here.op && (here.op & 0xf0) == 0) {
1039                 last = here;
1040                 for (;;) {
1041                     here = state->lencode[last.val +
1042                             (BITS(last.bits + last.op) >> last.bits)];
1043                     if ((unsigned)(last.bits + here.bits) <= bits) break;
1044                     PULLBYTE();
1045                 }
1046                 DROPBITS(last.bits);
1047                 state->back += last.bits;
1048             }
1049             DROPBITS(here.bits);
1050             state->back += here.bits;
1051             state->length = (unsigned)here.val;
1052             if ((int)(here.op) == 0) {
1053                 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
1054                         "inflate:         literal '%c'\n" :
1055                         "inflate:         literal 0x%02x\n", here.val));
1056                 state->mode = LIT;
1057                 break;
1058             }
1059             if (here.op & 32) {
1060                 Tracevv((stderr, "inflate:         end of block\n"));
1061                 state->back = -1;
1062                 state->mode = TYPE;
1063                 break;
1064             }
1065             if (here.op & 64) {
1066                 strm->msg = (char *)"invalid literal/length code";
1067                 state->mode = BAD;
1068                 break;
1069             }
1070             state->extra = (unsigned)(here.op) & 15;
1071             state->mode = LENEXT;
1072         case LENEXT:
1073             if (state->extra) {
1074                 NEEDBITS(state->extra);
1075                 state->length += BITS(state->extra);
1076                 DROPBITS(state->extra);
1077                 state->back += state->extra;
1078             }
1079             Tracevv((stderr, "inflate:         length %u\n", state->length));
1080             state->was = state->length;
1081             state->mode = DIST;
1082         case DIST:
1083             for (;;) {
1084                 here = state->distcode[BITS(state->distbits)];
1085                 if ((unsigned)(here.bits) <= bits) break;
1086                 PULLBYTE();
1087             }
1088             if ((here.op & 0xf0) == 0) {
1089                 last = here;
1090                 for (;;) {
1091                     here = state->distcode[last.val +
1092                             (BITS(last.bits + last.op) >> last.bits)];
1093                     if ((unsigned)(last.bits + here.bits) <= bits) break;
1094                     PULLBYTE();
1095                 }
1096                 DROPBITS(last.bits);
1097                 state->back += last.bits;
1098             }
1099             DROPBITS(here.bits);
1100             state->back += here.bits;
1101             if (here.op & 64) {
1102                 strm->msg = (char *)"invalid distance code";
1103                 state->mode = BAD;
1104                 break;
1105             }
1106             state->offset = (unsigned)here.val;
1107             state->extra = (unsigned)(here.op) & 15;
1108             state->mode = DISTEXT;
1109         case DISTEXT:
1110             if (state->extra) {
1111                 NEEDBITS(state->extra);
1112                 state->offset += BITS(state->extra);
1113                 DROPBITS(state->extra);
1114                 state->back += state->extra;
1115             }
1116 #ifdef INFLATE_STRICT
1117             if (state->offset > state->dmax) {
1118                 strm->msg = (char *)"invalid distance too far back";
1119                 state->mode = BAD;
1120                 break;
1121             }
1122 #endif
1123             Tracevv((stderr, "inflate:         distance %u\n", state->offset));
1124             state->mode = MATCH;
1125         case MATCH:
1126             if (left == 0) goto inf_leave;
1127             copy = out - left;
1128             if (state->offset > copy) {         /* copy from window */
1129                 copy = state->offset - copy;
1130                 if (copy > state->whave) {
1131                     if (state->sane) {
1132                         strm->msg = (char *)"invalid distance too far back";
1133                         state->mode = BAD;
1134                         break;
1135                     }
1136 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
1137                     Trace((stderr, "inflate.c too far\n"));
1138                     copy -= state->whave;
1139                     if (copy > state->length) copy = state->length;
1140                     if (copy > left) copy = left;
1141                     left -= copy;
1142                     state->length -= copy;
1143                     do {
1144                         *put++ = 0;
1145                     } while (--copy);
1146                     if (state->length == 0) state->mode = LEN;
1147                     break;
1148 #endif
1149                 }
1150                 if (copy > state->wnext) {
1151                     copy -= state->wnext;
1152                     from = state->window + (state->wsize - copy);
1153                 }
1154                 else
1155                     from = state->window + (state->wnext - copy);
1156                 if (copy > state->length) copy = state->length;
1157             }
1158             else {                              /* copy from output */
1159                 from = put - state->offset;
1160                 copy = state->length;
1161             }
1162             if (copy > left) copy = left;
1163             left -= copy;
1164             state->length -= copy;
1165             do {
1166                 *put++ = *from++;
1167             } while (--copy);
1168             if (state->length == 0) state->mode = LEN;
1169             break;
1170         case LIT:
1171             if (left == 0) goto inf_leave;
1172             *put++ = (unsigned char)(state->length);
1173             left--;
1174             state->mode = LEN;
1175             break;
1176         case CHECK:
1177             if (state->wrap) {
1178                 NEEDBITS(32);
1179                 out -= left;
1180                 strm->total_out += out;
1181                 state->total += out;
1182                 if (out)
1183                     strm->adler = state->check =
1184                         UPDATE(state->check, put - out, out);
1185                 out = left;
1186                 if ((
1187 #ifdef GUNZIP
1188                      state->flags ? hold :
1189 #endif
1190                      ZSWAP32(hold)) != state->check) {
1191                     strm->msg = (char *)"incorrect data check";
1192                     state->mode = BAD;
1193                     break;
1194                 }
1195                 INITBITS();
1196                 Tracev((stderr, "inflate:   check matches trailer\n"));
1197             }
1198 #ifdef GUNZIP
1199             state->mode = LENGTH;
1200         case LENGTH:
1201             if (state->wrap && state->flags) {
1202                 NEEDBITS(32);
1203                 if (hold != (state->total & 0xffffffffUL)) {
1204                     strm->msg = (char *)"incorrect length check";
1205                     state->mode = BAD;
1206                     break;
1207                 }
1208                 INITBITS();
1209                 Tracev((stderr, "inflate:   length matches trailer\n"));
1210             }
1211 #endif
1212             state->mode = DONE;
1213         case DONE:
1214             ret = Z_STREAM_END;
1215             goto inf_leave;
1216         case BAD:
1217             ret = Z_DATA_ERROR;
1218             goto inf_leave;
1219         case MEM:
1220             return Z_MEM_ERROR;
1221         case SYNC:
1222         default:
1223             return Z_STREAM_ERROR;
1224         }
1225
1226     /*
1227        Return from inflate(), updating the total counts and the check value.
1228        If there was no progress during the inflate() call, return a buffer
1229        error.  Call updatewindow() to create and/or update the window state.
1230        Note: a memory error from inflate() is non-recoverable.
1231      */
1232   inf_leave:
1233     RESTORE();
1234     if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
1235             (state->mode < CHECK || flush != Z_FINISH)))
1236         if (updatewindow(strm, strm->next_out, out - strm->avail_out)) {
1237             state->mode = MEM;
1238             return Z_MEM_ERROR;
1239         }
1240     in -= strm->avail_in;
1241     out -= strm->avail_out;
1242     strm->total_in += in;
1243     strm->total_out += out;
1244     state->total += out;
1245     if (state->wrap && out)
1246         strm->adler = state->check =
1247             UPDATE(state->check, strm->next_out - out, out);
1248     strm->data_type = state->bits + (state->last ? 64 : 0) +
1249                       (state->mode == TYPE ? 128 : 0) +
1250                       (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
1251     if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1252         ret = Z_BUF_ERROR;
1253     return ret;
1254 }
1255
1256 int ZEXPORT inflateEnd(strm)
1257 z_streamp strm;
1258 {
1259     struct inflate_state FAR *state;
1260     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
1261         return Z_STREAM_ERROR;
1262     state = (struct inflate_state FAR *)strm->state;
1263     if (state->window != Z_NULL) ZFREE(strm, state->window);
1264     ZFREE(strm, strm->state);
1265     strm->state = Z_NULL;
1266     Tracev((stderr, "inflate: end\n"));
1267     return Z_OK;
1268 }
1269
1270 int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength)
1271 z_streamp strm;
1272 Bytef *dictionary;
1273 uInt *dictLength;
1274 {
1275     struct inflate_state FAR *state;
1276
1277     /* check state */
1278     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1279     state = (struct inflate_state FAR *)strm->state;
1280
1281     /* copy dictionary */
1282     if (state->whave && dictionary != Z_NULL) {
1283         zmemcpy(dictionary, state->window + state->wnext,
1284                 state->whave - state->wnext);
1285         zmemcpy(dictionary + state->whave - state->wnext,
1286                 state->window, state->wnext);
1287     }
1288     if (dictLength != Z_NULL)
1289         *dictLength = state->whave;
1290     return Z_OK;
1291 }
1292
1293 int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
1294 z_streamp strm;
1295 const Bytef *dictionary;
1296 uInt dictLength;
1297 {
1298     struct inflate_state FAR *state;
1299     unsigned long dictid;
1300     int ret;
1301
1302     /* check state */
1303     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1304     state = (struct inflate_state FAR *)strm->state;
1305     if (state->wrap != 0 && state->mode != DICT)
1306         return Z_STREAM_ERROR;
1307
1308     /* check for correct dictionary identifier */
1309     if (state->mode == DICT) {
1310         dictid = adler32(0L, Z_NULL, 0);
1311         dictid = adler32(dictid, dictionary, dictLength);
1312         if (dictid != state->check)
1313             return Z_DATA_ERROR;
1314     }
1315
1316     /* copy dictionary to window using updatewindow(), which will amend the
1317        existing dictionary if appropriate */
1318     ret = updatewindow(strm, dictionary + dictLength, dictLength);
1319     if (ret) {
1320         state->mode = MEM;
1321         return Z_MEM_ERROR;
1322     }
1323     state->havedict = 1;
1324     Tracev((stderr, "inflate:   dictionary set\n"));
1325     return Z_OK;
1326 }
1327
1328 int ZEXPORT inflateGetHeader(strm, head)
1329 z_streamp strm;
1330 gz_headerp head;
1331 {
1332     struct inflate_state FAR *state;
1333
1334     /* check state */
1335     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1336     state = (struct inflate_state FAR *)strm->state;
1337     if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1338
1339     /* save header structure */
1340     state->head = head;
1341     head->done = 0;
1342     return Z_OK;
1343 }
1344
1345 /*
1346    Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
1347    or when out of input.  When called, *have is the number of pattern bytes
1348    found in order so far, in 0..3.  On return *have is updated to the new
1349    state.  If on return *have equals four, then the pattern was found and the
1350    return value is how many bytes were read including the last byte of the
1351    pattern.  If *have is less than four, then the pattern has not been found
1352    yet and the return value is len.  In the latter case, syncsearch() can be
1353    called again with more data and the *have state.  *have is initialized to
1354    zero for the first call.
1355  */
1356 local unsigned syncsearch(have, buf, len)
1357 unsigned FAR *have;
1358 const unsigned char FAR *buf;
1359 unsigned len;
1360 {
1361     unsigned got;
1362     unsigned next;
1363
1364     got = *have;
1365     next = 0;
1366     while (next < len && got < 4) {
1367         if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
1368             got++;
1369         else if (buf[next])
1370             got = 0;
1371         else
1372             got = 4 - got;
1373         next++;
1374     }
1375     *have = got;
1376     return next;
1377 }
1378
1379 int ZEXPORT inflateSync(strm)
1380 z_streamp strm;
1381 {
1382     unsigned len;               /* number of bytes to look at or looked at */
1383     unsigned long in, out;      /* temporary to save total_in and total_out */
1384     unsigned char buf[4];       /* to restore bit buffer to byte string */
1385     struct inflate_state FAR *state;
1386
1387     /* check parameters */
1388     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1389     state = (struct inflate_state FAR *)strm->state;
1390     if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1391
1392     /* if first time, start search in bit buffer */
1393     if (state->mode != SYNC) {
1394         state->mode = SYNC;
1395         state->hold <<= state->bits & 7;
1396         state->bits -= state->bits & 7;
1397         len = 0;
1398         while (state->bits >= 8) {
1399             buf[len++] = (unsigned char)(state->hold);
1400             state->hold >>= 8;
1401             state->bits -= 8;
1402         }
1403         state->have = 0;
1404         syncsearch(&(state->have), buf, len);
1405     }
1406
1407     /* search available input */
1408     len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1409     strm->avail_in -= len;
1410     strm->next_in += len;
1411     strm->total_in += len;
1412
1413     /* return no joy or set up to restart inflate() on a new block */
1414     if (state->have != 4) return Z_DATA_ERROR;
1415     in = strm->total_in;  out = strm->total_out;
1416     inflateReset(strm);
1417     strm->total_in = in;  strm->total_out = out;
1418     state->mode = TYPE;
1419     return Z_OK;
1420 }
1421
1422 /*
1423    Returns true if inflate is currently at the end of a block generated by
1424    Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
1425    implementation to provide an additional safety check. PPP uses
1426    Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
1427    block. When decompressing, PPP checks that at the end of input packet,
1428    inflate is waiting for these length bytes.
1429  */
1430 int ZEXPORT inflateSyncPoint(strm)
1431 z_streamp strm;
1432 {
1433     struct inflate_state FAR *state;
1434
1435     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1436     state = (struct inflate_state FAR *)strm->state;
1437     return state->mode == STORED && state->bits == 0;
1438 }
1439
1440 int ZEXPORT inflateCopy(dest, source)
1441 z_streamp dest;
1442 z_streamp source;
1443 {
1444     struct inflate_state FAR *state;
1445     struct inflate_state FAR *copy;
1446     unsigned char FAR *window;
1447     unsigned wsize;
1448
1449     /* check input */
1450     if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
1451         source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
1452         return Z_STREAM_ERROR;
1453     state = (struct inflate_state FAR *)source->state;
1454
1455     /* allocate space */
1456     copy = (struct inflate_state FAR *)
1457            ZALLOC(source, 1, sizeof(struct inflate_state));
1458     if (copy == Z_NULL) return Z_MEM_ERROR;
1459     window = Z_NULL;
1460     if (state->window != Z_NULL) {
1461         window = (unsigned char FAR *)
1462                  ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1463         if (window == Z_NULL) {
1464             ZFREE(source, copy);
1465             return Z_MEM_ERROR;
1466         }
1467     }
1468
1469     /* copy state */
1470     zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
1471     zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
1472     if (state->lencode >= state->codes &&
1473         state->lencode <= state->codes + ENOUGH - 1) {
1474         copy->lencode = copy->codes + (state->lencode - state->codes);
1475         copy->distcode = copy->codes + (state->distcode - state->codes);
1476     }
1477     copy->next = copy->codes + (state->next - state->codes);
1478     if (window != Z_NULL) {
1479         wsize = 1U << state->wbits;
1480         zmemcpy(window, state->window, wsize);
1481     }
1482     copy->window = window;
1483     dest->state = (struct internal_state FAR *)copy;
1484     return Z_OK;
1485 }
1486
1487 int ZEXPORT inflateUndermine(strm, subvert)
1488 z_streamp strm;
1489 int subvert;
1490 {
1491     struct inflate_state FAR *state;
1492
1493     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1494     state = (struct inflate_state FAR *)strm->state;
1495 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
1496     state->sane = !subvert;
1497     return Z_OK;
1498 #else
1499     state->sane = 1;
1500     return Z_DATA_ERROR;
1501 #endif
1502 }
1503
1504 long ZEXPORT inflateMark(strm)
1505 z_streamp strm;
1506 {
1507     struct inflate_state FAR *state;
1508
1509     if (strm == Z_NULL || strm->state == Z_NULL)
1510         return (long)(((unsigned long)0 - 1) << 16);
1511     state = (struct inflate_state FAR *)strm->state;
1512     return (long)(((unsigned long)((long)state->back)) << 16) +
1513         (state->mode == COPY ? state->length :
1514             (state->mode == MATCH ? state->was - state->length : 0));
1515 }
1516
1517 unsigned long ZEXPORT inflateCodesUsed(strm)
1518 z_streamp strm;
1519 {
1520     struct inflate_state FAR *state;
1521     if (strm == Z_NULL || strm->state == Z_NULL) return -1L;
1522     state = (struct inflate_state FAR *)strm->state;
1523     return state->next - state->codes;
1524 }