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