source: rtems/cpukit/zlib/inflate.c @ 23c71a8

4.11
Last change on this file since 23c71a8 was 23c71a8, checked in by Ralf Corsepius <ralf.corsepius@…>, on Mar 18, 2011 at 10:11:13 AM

Import from zlib-1.2.4

  • Property mode set to 100644
File size: 51.4 KB
Line 
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 */
95local void fixedtables OF((struct inflate_state FAR *state));
96local int updatewindow OF((z_streamp strm, unsigned out));
97#ifdef BUILDFIXED
98   void makefixed OF((void));
99#endif
100local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
101                              unsigned len));
102
103int ZEXPORT inflateReset(strm)
104z_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
130int ZEXPORT inflateReset2(strm, windowBits)
131z_streamp strm;
132int 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
168int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
169z_streamp strm;
170int windowBits;
171const char *version;
172int 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
201int ZEXPORT inflateInit_(strm, version, stream_size)
202z_streamp strm;
203const char *version;
204int stream_size;
205{
206    return inflateInit2_(strm, DEF_WBITS, version, stream_size);
207}
208
209int ZEXPORT inflatePrime(strm, bits, value)
210z_streamp strm;
211int bits;
212int 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 */
240local void fixedtables(state)
241struct 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 */
304void 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 */
358local int updatewindow(strm, out)
359z_streamp strm;
360unsigned 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
589int ZEXPORT inflate(strm, flush)
590z_streamp strm;
591int 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
1238int ZEXPORT inflateEnd(strm)
1239z_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
1252int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
1253z_streamp strm;
1254const Bytef *dictionary;
1255uInt 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
1294int ZEXPORT inflateGetHeader(strm, head)
1295z_streamp strm;
1296gz_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 */
1322local unsigned syncsearch(have, buf, len)
1323unsigned FAR *have;
1324unsigned char FAR *buf;
1325unsigned 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
1345int ZEXPORT inflateSync(strm)
1346z_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 */
1396int ZEXPORT inflateSyncPoint(strm)
1397z_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
1406int ZEXPORT inflateCopy(dest, source)
1407z_streamp dest;
1408z_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
1453int ZEXPORT inflateUndermine(strm, subvert)
1454z_streamp strm;
1455int 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
1470long ZEXPORT inflateMark(strm)
1471z_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}
Note: See TracBrowser for help on using the repository browser.