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