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