Code Coverage: vinyl-cache/lib/libvgz/inflate.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
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 30543
local int inflateStateCheck(z_streamp strm) {
94 30543
    struct inflate_state FAR *state;
95 30543
    if (strm == Z_NULL ||
96 30543
        strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
97 0
        return 1;
98 30543
    state = (struct inflate_state FAR *)strm->state;
99 30543
    if (state == Z_NULL || state->strm != strm ||
100 30543
        state->mode < HEAD || state->mode > SYNC)
101 0
        return 1;
102 30543
    return 0;
103 30543
}
104
105 937
int ZEXPORT inflateResetKeep(z_streamp strm) {
106 937
    struct inflate_state FAR *state;
107
108 937
    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
109 937
    state = (struct inflate_state FAR *)strm->state;
110 937
    strm->total_in = strm->total_out = state->total = 0;
111 937
    strm->start_bit = strm->stop_bit = strm->last_bit = 0;
112 937
    strm->msg = Z_NULL;
113 937
    if (state->wrap)        /* to support ill-conceived Java test suite */
114 937
        strm->adler = state->wrap & 1;
115 937
    state->mode = HEAD;
116 937
    state->last = 0;
117 937
    state->havedict = 0;
118 937
    state->flags = -1;
119 937
    state->dmax = 32768U;
120 937
    state->head = Z_NULL;
121 937
    state->hold = 0;
122 937
    state->bits = 0;
123 937
    state->lencode = state->distcode = state->next = state->codes;
124 937
    state->sane = 1;
125 937
    state->back = -1;
126 937
    Tracev((stderr, "inflate: reset\n"));
127 937
    return Z_OK;
128 937
}
129
130 937
int ZEXPORT inflateReset(z_streamp strm) {
131 937
    struct inflate_state FAR *state;
132
133 937
    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
134 937
    state = (struct inflate_state FAR *)strm->state;
135 937
    state->wsize = 0;
136 937
    state->whave = 0;
137 937
    state->wnext = 0;
138 937
    return inflateResetKeep(strm);
139 937
}
140
141 937
int ZEXPORT inflateReset2(z_streamp strm, int windowBits) {
142 937
    int wrap;
143 937
    struct inflate_state FAR *state;
144
145
    /* get the state */
146 937
    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
147 937
    state = (struct inflate_state FAR *)strm->state;
148
149
    /* extract wrap request from windowBits parameter */
150 937
    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 937
    else {
157 937
        wrap = (windowBits >> 4) + 5;
158 937
#ifdef GUNZIP
159 937
        if (windowBits < 48)
160 937
            windowBits &= 15;
161 937
#endif
162 937
    }
163
164
    /* set number of window bits, free window if different */
165 937
    if (windowBits && (windowBits < 8 || windowBits > 15))
166 0
        return Z_STREAM_ERROR;
167 937
    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 937
    state->wrap = wrap;
174 937
    state->wbits = (unsigned)windowBits;
175 937
    return inflateReset(strm);
176 937
}
177
178
int ZEXPORT inflateInit2_(z_streamp strm, int windowBits,
179 937
                          const char *version, int stream_size) {
180 937
    int ret;
181 937
    struct inflate_state FAR *state;
182
183 937
    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
184 937
        stream_size != (int)(sizeof(z_stream)))
185 0
        return Z_VERSION_ERROR;
186 937
    if (strm == Z_NULL) return Z_STREAM_ERROR;
187 937
    strm->msg = Z_NULL;                 /* in case we return an error */
188 937
    if (strm->zalloc == (alloc_func)0) {
189
#ifdef Z_SOLO
190
        return Z_STREAM_ERROR;
191
#else
192 937
        strm->zalloc = zcalloc;
193 937
        strm->opaque = (voidpf)0;
194 937
#endif
195 937
    }
196 937
    if (strm->zfree == (free_func)0)
197
#ifdef Z_SOLO
198
        return Z_STREAM_ERROR;
199
#else
200 937
        strm->zfree = zcfree;
201 937
#endif
202 937
    state = (struct inflate_state FAR *)
203 937
            ZALLOC(strm, 1, sizeof(struct inflate_state));
204 937
    if (state == Z_NULL) return Z_MEM_ERROR;
205 937
    Tracev((stderr, "inflate: allocated\n"));
206 937
    strm->state = (struct internal_state FAR *)state;
207 937
    state->strm = strm;
208 937
    state->window = Z_NULL;
209 937
    state->mode = HEAD;     /* to pass state test in inflateReset2() */
210 937
    ret = inflateReset2(strm, windowBits);
211 937
    if (ret != Z_OK) {
212 0
        ZFREE(strm, state);
213 0
        strm->state = Z_NULL;
214 0
    }
215 937
    return ret;
216 937
}
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 6628
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 6628
#   include "inffixed.h"
290 6628
#endif /* BUILDFIXED */
291 6628
    state->lencode = lenfix;
292 6628
    state->lenbits = 9;
293 6628
    state->distcode = distfix;
294 6628
    state->distbits = 5;
295 6628
}
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 25836
local int updatewindow(z_streamp strm, const Bytef *end, unsigned copy) {
373 25836
    struct inflate_state FAR *state;
374 25836
    unsigned dist;
375
376 25836
    state = (struct inflate_state FAR *)strm->state;
377
378
    /* if it hasn't been done already, allocate space for the window */
379 25836
    if (state->window == Z_NULL) {
380 436
        state->window = (unsigned char FAR *)
381 436
                        ZALLOC(strm, 1U << state->wbits,
382 436
                               sizeof(unsigned char));
383 436
        if (state->window == Z_NULL) return 1;
384 436
    }
385
386
    /* if window not in use yet, initialize */
387 25836
    if (state->wsize == 0) {
388 436
        state->wsize = 1U << state->wbits;
389 436
        state->wnext = 0;
390 436
        state->whave = 0;
391 436
    }
392
393
    /* copy state->wsize or less output bytes into the circular window */
394 25836
    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 25836
    else {
400 25836
        dist = state->wsize - state->wnext;
401 25836
        if (dist > copy) dist = copy;
402 25836
        zmemcpy(state->window + state->wnext, end - copy, dist);
403 25836
        copy -= dist;
404 25836
        if (copy) {
405 302
            zmemcpy(state->window, end - copy, copy);
406 302
            state->wnext = copy;
407 302
            state->whave = state->wsize;
408 302
        }
409 25534
        else {
410 25534
            state->wnext += dist;
411 25534
            if (state->wnext == state->wsize) state->wnext = 0;
412 25534
            if (state->whave < state->wsize) state->whave += dist;
413 25534
        }
414 25836
    }
415 25836
    return 0;
416 25836
}
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 13774
    (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 817
    do { \
432 817
        hbuf[0] = (unsigned char)(word); \
433 817
        hbuf[1] = (unsigned char)((word) >> 8); \
434 817
        check = crc32(check, hbuf, 2); \
435 817
    } while (0)
436
437
#  define CRC4(check, word) \
438 2
    do { \
439 2
        hbuf[0] = (unsigned char)(word); \
440 2
        hbuf[1] = (unsigned char)((word) >> 8); \
441 2
        hbuf[2] = (unsigned char)((word) >> 16); \
442 2
        hbuf[3] = (unsigned char)((word) >> 24); \
443 2
        check = crc32(check, hbuf, 4); \
444 2
    } while (0)
445
#endif
446
447
/* Load registers with state in inflate() for speed */
448
#define LOAD() \
449 42047
    do { \
450 42047
        put = strm->next_out; \
451 42047
        left = strm->avail_out; \
452 42047
        next = strm->next_in; \
453 42047
        have = strm->avail_in; \
454 42047
        hold = state->hold; \
455 42047
        bits = state->bits; \
456 42047
    } while (0)
457
458
/* Restore state from registers in inflate() */
459
#define RESTORE() \
460 42045
    do { \
461 42045
        strm->next_out = put; \
462 42045
        strm->avail_out = left; \
463 42045
        strm->next_in = next; \
464 42045
        strm->avail_in = have; \
465 42045
        state->hold = hold; \
466 42045
        state->bits = bits; \
467 42045
    } while (0)
468
469
/* Clear the input bit accumulator */
470
#define INITBITS() \
471 16351
    do { \
472 16351
        hold = 0; \
473 16351
        bits = 0; \
474 16351
    } 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 922484
    do { \
480 922484
        if (have == 0) goto inf_leave; \
481 922484
        have--; \
482 917480
        hold += (unsigned long)(*next++) << bits; \
483 917480
        bits += 8; \
484 917480
    } 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 300242
    do { \
490 558821
        while (bits < (unsigned)(n)) \
491 300242
            PULLBYTE(); \
492 300242
    } while (0)
493
494
/* Return the low n bits of the bit accumulator (n < 16) */
495
#define BITS(n) \
496 1894401
    ((unsigned)hold & ((1U << (n)) - 1))
497
498
/* Remove n bits from the bit accumulator */
499
#define DROPBITS(n) \
500 1234751
    do { \
501 1234751
        hold >>= (n); \
502 1234751
        bits -= (unsigned)(n); \
503 1234751
    } while (0)
504
505
/* Remove zero to seven bits as needed to go to a byte boundary */
506
#define BYTEBITS() \
507 12432
    do { \
508 12432
        hold >>= bits & 7; \
509 12432
        bits -= bits & 7; \
510 12432
    } 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 26796
int ZEXPORT inflate(z_streamp strm, int flush) {
595 26796
    struct inflate_state FAR *state;
596 26796
    z_const unsigned char FAR *next;    /* next input */
597 26796
    unsigned char FAR *put;     /* next output */
598 26796
    unsigned have, left;        /* available input and output */
599 26796
    unsigned long hold;         /* bit buffer */
600 26796
    unsigned bits;              /* bits in bit buffer */
601 26796
    unsigned in, out;           /* save starting available input and output */
602 26796
    unsigned copy;              /* number of stored or match bytes to copy */
603 26796
    unsigned char FAR *from;    /* where to copy match bytes from */
604 26796
    code here;                  /* current decoding table entry */
605 26796
    code last;                  /* parent table entry */
606 26796
    unsigned len;               /* length to copy for repeats, bits to drop */
607 26796
    int ret;                    /* return code */
608 26796
#ifdef GUNZIP
609 26796
    unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
610 26796
#endif
611 26796
    static const unsigned short order[19] = /* permutation of code lengths */
612 26796
        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
613
614 26796
    if (inflateStateCheck(strm) || strm->next_out == Z_NULL ||
615 26797
        (strm->next_in == Z_NULL && strm->avail_in != 0))
616 0
        return Z_STREAM_ERROR;
617
618 26796
    state = (struct inflate_state FAR *)strm->state;
619 26796
    if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
620 26796
    LOAD();
621 26796
    in = have;
622 26796
    out = left;
623 26796
    ret = Z_OK;
624 26796
    for (;;)
625 1043287
        switch (state->mode) {
626 1123
        case HEAD:
627 1123
            if (state->wrap == 0) {
628 0
                state->mode = TYPEDO;
629 0
                break;
630 0
            }
631 1123
            NEEDBITS(16);
632 859
#ifdef GUNZIP
633 859
            if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
634 811
                if (state->wbits == 0)
635 0
                    state->wbits = 15;
636 811
                state->check = crc32(0L, Z_NULL, 0);
637 811
                CRC2(state->check, hold);
638 811
                INITBITS();
639 811
                state->mode = FLAGS;
640 811
                break;
641 811
            }
642 48
            if (state->head != Z_NULL)
643 0
                state->head->done = -1;
644 48
            if (!(state->wrap & 1) ||   /* check if zlib header allowed */
645
#else
646
            if (
647
#endif
648 48
                ((BITS(8) << 8) + (hold >> 8)) % 31) {
649 48
                strm->msg = (z_const char *)"incorrect header check";
650 48
                state->mode = BAD;
651 48
                break;
652 48
            }
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 0
            }
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 0
            }
667 0
            state->dmax = 1U << len;
668 0
            state->flags = 0;               /* indicate zlib header */
669 0
            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 0
#ifdef GUNZIP
675 815
        case FLAGS:
676 815
            NEEDBITS(16);
677 811
            state->flags = (int)(hold);
678 811
            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 0
            }
683 811
            if (state->flags & 0xe000) {
684 0
                strm->msg = (z_const char *)"unknown header flags set";
685 0
                state->mode = BAD;
686 0
                break;
687 0
            }
688 811
            if (state->head != Z_NULL)
689 0
                state->head->text = (int)((hold >> 8) & 1);
690 811
            if ((state->flags & 0x0200) && (state->wrap & 4))
691 2
                CRC2(state->check, hold);
692 811
            INITBITS();
693 811
            state->mode = TIME;
694
                /* fallthrough */
695 815
        case TIME:
696 815
            NEEDBITS(32);
697 811
            if (state->head != Z_NULL)
698 0
                state->head->time = hold;
699 811
            if ((state->flags & 0x0200) && (state->wrap & 4))
700 2
                CRC4(state->check, hold);
701 811
            INITBITS();
702 811
            state->mode = OS;
703
                /* fallthrough */
704 813
        case OS:
705 813
            NEEDBITS(16);
706 811
            if (state->head != Z_NULL) {
707 0
                state->head->xflags = (int)(hold & 0xff);
708 0
                state->head->os = (int)(hold >> 8);
709 0
            }
710 811
            if ((state->flags & 0x0200) && (state->wrap & 4))
711 2
                CRC2(state->check, hold);
712 811
            INITBITS();
713 811
            state->mode = EXLEN;
714
                /* fallthrough */
715 811
        case EXLEN:
716 811
            if (state->flags & 0x0400) {
717 2
                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 809
            else if (state->head != Z_NULL)
726 0
                state->head->extra = Z_NULL;
727 811
            state->mode = EXTRA;
728
                /* fallthrough */
729 811
        case EXTRA:
730 811
            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 2
                        state->head->extra != Z_NULL &&
736 2
                        (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 811
            state->length = 0;
751 811
            state->mode = NAME;
752
                /* fallthrough */
753 811
        case NAME:
754 811
            if (state->flags & 0x0800) {
755 159
                if (have == 0) goto inf_leave;
756 159
                copy = 0;
757 2454
                do {
758 2454
                    len = (unsigned)(next[copy++]);
759 2454
                    if (state->head != Z_NULL &&
760 2454
                            state->head->name != Z_NULL &&
761 2454
                            state->length < state->head->name_max)
762 0
                        state->head->name[state->length++] = (Bytef)len;
763 2454
                } while (len && copy < have);
764 159
                if ((state->flags & 0x0200) && (state->wrap & 4))
765 2
                    state->check = crc32(state->check, next, copy);
766 159
                have -= copy;
767 159
                next += copy;
768 159
                if (len) goto inf_leave;
769 159
            }
770 652
            else if (state->head != Z_NULL)
771 0
                state->head->name = Z_NULL;
772 811
            state->length = 0;
773 811
            state->mode = COMMENT;
774
                /* fallthrough */
775 811
        case COMMENT:
776 811
            if (state->flags & 0x1000) {
777 2
                if (have == 0) goto inf_leave;
778 2
                copy = 0;
779 18
                do {
780 18
                    len = (unsigned)(next[copy++]);
781 18
                    if (state->head != Z_NULL &&
782 18
                            state->head->comment != Z_NULL &&
783 18
                            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 809
            else if (state->head != Z_NULL)
793 0
                state->head->comment = Z_NULL;
794 811
            state->mode = HCRC;
795
                /* fallthrough */
796 811
        case HCRC:
797 811
            if (state->flags & 0x0200) {
798 2
                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 0
                }
804 2
                INITBITS();
805 2
            }
806 811
            if (state->head != Z_NULL) {
807 0
                state->head->hcrc = (int)((state->flags >> 9) & 1);
808 0
                state->head->done = 1;
809 0
            }
810 811
            strm->adler = state->check = crc32(0L, Z_NULL, 0);
811 811
            state->mode = TYPE;
812 811
            break;
813 0
#endif
814 0
        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 0
        case DICT:
821 0
            if (state->havedict == 0) {
822 0
                RESTORE();
823 0
                return Z_NEED_DICT;
824 0
            }
825 0
            strm->adler = state->check = adler32(0L, Z_NULL, 0);
826 0
            state->mode = TYPE;
827
                /* fallthrough */
828 19331
        case TYPE:
829 19331
            if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
830
                /* fallthrough */
831 23138
        case TYPEDO:
832 23138
            if (strm->start_bit == 0)
833 811
                strm->start_bit = 8 * (strm->total_in + in - have) - bits;
834 23138
            if (state->last) {
835 677
                strm->stop_bit = 8 * (strm->total_in + in - have) - bits;
836 677
                BYTEBITS();
837 677
                state->mode = CHECK;
838 677
                break;
839 677
            }
840 22461
            NEEDBITS(3);
841 18655
            state->last = BITS(1);
842 18655
            if (state->last)
843 683
                strm->last_bit = 8 * (strm->total_in + in - have) - bits;
844 18655
            DROPBITS(1);
845 18655
            switch (BITS(2)) {
846 11750
            case 0:                             /* stored block */
847 11750
                Tracev((stderr, "inflate:     stored block%s\n",
848 11750
                        state->last ? " (last)" : ""));
849 11750
                state->mode = STORED;
850 11750
                break;
851 6629
            case 1:                             /* fixed block */
852 6629
                fixedtables(state);
853 6629
                Tracev((stderr, "inflate:     fixed codes block%s\n",
854 6629
                        state->last ? " (last)" : ""));
855 6629
                state->mode = LEN_;             /* decode codes */
856 6629
                if (flush == Z_TREES) {
857 0
                    DROPBITS(2);
858 0
                    goto inf_leave;
859 0
                }
860 6629
                break;
861 6629
            case 2:                             /* dynamic block */
862 282
                Tracev((stderr, "inflate:     dynamic codes block%s\n",
863 282
                        state->last ? " (last)" : ""));
864 282
                state->mode = TABLE;
865 282
                break;
866 0
            case 3:
867 0
                strm->msg = (z_const char *)"invalid block type";
868 0
                state->mode = BAD;
869 18655
            }
870 18659
            DROPBITS(2);
871 18659
            break;
872 11755
        case STORED:
873 11755
            BYTEBITS();                         /* go to byte boundary */
874 11755
            NEEDBITS(32);
875 11749
            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 0
            }
880 11749
            state->length = (unsigned)hold & 0xffff;
881 11749
            Tracev((stderr, "inflate:       stored length %u\n",
882 11749
                    state->length));
883 11749
            INITBITS();
884 11749
            state->mode = COPY_;
885 11749
            if (flush == Z_TREES) goto inf_leave;
886
                /* fallthrough */
887 11749
        case COPY_:
888 11749
            state->mode = COPY;
889
                /* fallthrough */
890 21034
        case COPY:
891 21034
            copy = state->length;
892 21034
            if (copy) {
893 9287
                if (copy > have) copy = have;
894 9287
                if (copy > left) copy = left;
895 9287
                if (copy == 0) goto inf_leave;
896 5889
                zmemcpy(put, next, copy);
897 5889
                have -= copy;
898 5889
                next += copy;
899 5889
                left -= copy;
900 5889
                put += copy;
901 5889
                state->length -= copy;
902 5889
                break;
903 9287
            }
904 11747
            Tracev((stderr, "inflate:       stored end\n"));
905 11747
            state->mode = TYPE;
906 11747
            break;
907 282
        case TABLE:
908 282
            NEEDBITS(14);
909 282
            state->nlen = BITS(5) + 257;
910 282
            DROPBITS(5);
911 282
            state->ndist = BITS(5) + 1;
912 282
            DROPBITS(5);
913 282
            state->ncode = BITS(4) + 4;
914 282
            DROPBITS(4);
915 282
#ifndef PKZIP_BUG_WORKAROUND
916 282
            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 0
            }
921 282
#endif
922 282
            Tracev((stderr, "inflate:       table sizes ok\n"));
923 282
            state->have = 0;
924 282
            state->mode = LENLENS;
925
                /* fallthrough */
926 282
        case LENLENS:
927 5024
            while (state->have < state->ncode) {
928 4742
                NEEDBITS(3);
929 4742
                state->lens[order[state->have++]] = (unsigned short)BITS(3);
930 4742
                DROPBITS(3);
931 4742
            }
932 898
            while (state->have < 19)
933 616
                state->lens[order[state->have++]] = 0;
934 282
            state->next = state->codes;
935 282
            state->lencode = state->distcode = (const code FAR *)(state->next);
936 282
            state->lenbits = 7;
937 282
            ret = inflate_table(CODES, state->lens, 19, &(state->next),
938 282
                                &(state->lenbits), state->work);
939 282
            if (ret) {
940 0
                strm->msg = (z_const char *)"invalid code lengths set";
941 0
                state->mode = BAD;
942 0
                break;
943 0
            }
944 282
            Tracev((stderr, "inflate:       code lengths ok\n"));
945 282
            state->have = 0;
946 282
            state->mode = CODELENS;
947
                /* fallthrough */
948 285
        case CODELENS:
949 77456
            while (state->have < state->nlen + state->ndist) {
950 105603
                for (;;) {
951 105603
                    here = state->lencode[BITS(state->lenbits)];
952 105603
                    if ((unsigned)(here.bits) <= bits) break;
953 28432
                    PULLBYTE();
954 28432
                }
955 77171
                if (here.val < 16) {
956 74311
                    DROPBITS(here.bits);
957 74311
                    state->lens[state->have++] = here.val;
958 74311
                }
959 2860
                else {
960 2860
                    if (here.val == 16) {
961 2744
                        NEEDBITS(here.bits + 2);
962 2744
                        DROPBITS(here.bits);
963 2744
                        if (state->have == 0) {
964 0
                            strm->msg = (z_const char *)"invalid bit length repeat";
965 0
                            state->mode = BAD;
966 0
                            break;
967 0
                        }
968 2744
                        len = state->lens[state->have - 1];
969 2744
                        copy = 3 + BITS(2);
970 2744
                        DROPBITS(2);
971 2744
                    }
972 116
                    else if (here.val == 17) {
973 84
                        NEEDBITS(here.bits + 3);
974 84
                        DROPBITS(here.bits);
975 84
                        len = 0;
976 84
                        copy = 3 + BITS(3);
977 84
                        DROPBITS(3);
978 84
                    }
979 32
                    else {
980 32
                        NEEDBITS(here.bits + 7);
981 32
                        DROPBITS(here.bits);
982 32
                        len = 0;
983 32
                        copy = 11 + BITS(7);
984 32
                        DROPBITS(7);
985 32
                    }
986 2860
                    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 0
                    }
991 15660
                    while (copy--)
992 12800
                        state->lens[state->have++] = (unsigned short)len;
993 2860
                }
994 77171
            }
995
996
            /* handle error breaks in while */
997 279
            if (state->mode == BAD) break;
998
999
            /* check for end-of-block code (better have one) */
1000 279
            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 0
            }
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 279
            state->next = state->codes;
1010 279
            state->lencode = (const code FAR *)(state->next);
1011 279
            state->lenbits = 9;
1012 279
            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1013 279
                                &(state->lenbits), state->work);
1014 279
            if (ret) {
1015 0
                strm->msg = (z_const char *)"invalid literal/lengths set";
1016 0
                state->mode = BAD;
1017 0
                break;
1018 0
            }
1019 279
            state->distcode = (const code FAR *)(state->next);
1020 279
            state->distbits = 6;
1021 279
            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1022 279
                            &(state->next), &(state->distbits), state->work);
1023 279
            if (ret) {
1024 0
                strm->msg = (z_const char *)"invalid distances set";
1025 0
                state->mode = BAD;
1026 0
                break;
1027 0
            }
1028 279
            Tracev((stderr, "inflate:       codes ok\n"));
1029 279
            state->mode = LEN_;
1030 279
            if (flush == Z_TREES) goto inf_leave;
1031
                /* fallthrough */
1032 6905
        case LEN_:
1033 6905
            state->mode = LEN;
1034
                /* fallthrough */
1035 599866
        case LEN:
1036 599866
            if (have >= 6 && left >= 258) {
1037 15251
                RESTORE();
1038 15251
                inflate_fast(strm, out);
1039 15251
                LOAD();
1040 15251
                if (state->mode == TYPE)
1041 5791
                    state->back = -1;
1042 15251
                break;
1043 15251
            }
1044 584615
            state->back = 0;
1045 1084207
            for (;;) {
1046 1084207
                here = state->lencode[BITS(state->lenbits)];
1047 1084207
                if ((unsigned)(here.bits) <= bits) break;
1048 500224
                PULLBYTE();
1049 500224
            }
1050 583983
            if (here.op && (here.op & 0xf0) == 0) {
1051 58930
                last = here;
1052 67736
                for (;;) {
1053 67736
                    here = state->lencode[last.val +
1054 67736
                            (BITS(last.bits + last.op) >> last.bits)];
1055 67736
                    if ((unsigned)(last.bits + here.bits) <= bits) break;
1056 8810
                    PULLBYTE();
1057 8810
                }
1058 58926
                DROPBITS(last.bits);
1059 58926
                state->back += last.bits;
1060 58926
            }
1061 583979
            DROPBITS(here.bits);
1062 583979
            state->back += here.bits;
1063 583979
            state->length = (unsigned)here.val;
1064 583979
            if ((int)(here.op) == 0) {
1065 371222
                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
1066 371222
                        "inflate:         literal '%c'\n" :
1067 371222
                        "inflate:         literal 0x%02x\n", here.val));
1068 371222
                state->mode = LIT;
1069 371222
                break;
1070 371222
            }
1071 212757
            if (here.op & 32) {
1072 986
                Tracevv((stderr, "inflate:         end of block\n"));
1073 986
                state->back = -1;
1074 986
                state->mode = TYPE;
1075 986
                break;
1076 986
            }
1077 211771
            if (here.op & 64) {
1078 0
                strm->msg = (z_const char *)"invalid literal/length code";
1079 0
                state->mode = BAD;
1080 0
                break;
1081 0
            }
1082 211771
            state->extra = (unsigned)(here.op) & 15;
1083 211771
            state->mode = LENEXT;
1084
                /* fallthrough */
1085 211772
        case LENEXT:
1086 211772
            if (state->extra) {
1087 43770
                NEEDBITS(state->extra);
1088 43768
                state->length += BITS(state->extra);
1089 43768
                DROPBITS(state->extra);
1090 43768
                state->back += state->extra;
1091 43768
            }
1092 211770
            Tracevv((stderr, "inflate:         length %u\n", state->length));
1093 211770
            state->was = state->length;
1094 211770
            state->mode = DIST;
1095
                /* fallthrough */
1096 211848
        case DIST:
1097 333100
            for (;;) {
1098 333100
                here = state->distcode[BITS(state->distbits)];
1099 333100
                if ((unsigned)(here.bits) <= bits) break;
1100 121355
                PULLBYTE();
1101 121355
            }
1102 211745
            if ((here.op & 0xf0) == 0) {
1103 4125
                last = here;
1104 4950
                for (;;) {
1105 4950
                    here = state->distcode[last.val +
1106 4950
                            (BITS(last.bits + last.op) >> last.bits)];
1107 4950
                    if ((unsigned)(last.bits + here.bits) <= bits) break;
1108 827
                    PULLBYTE();
1109 827
                }
1110 4123
                DROPBITS(last.bits);
1111 4123
                state->back += last.bits;
1112 4123
            }
1113 211743
            DROPBITS(here.bits);
1114 211743
            state->back += here.bits;
1115 211743
            if (here.op & 64) {
1116 0
                strm->msg = (z_const char *)"invalid distance code";
1117 0
                state->mode = BAD;
1118 0
                break;
1119 0
            }
1120 211743
            state->offset = (unsigned)here.val;
1121 211743
            state->extra = (unsigned)(here.op) & 15;
1122 211743
            state->mode = DISTEXT;
1123
                /* fallthrough */
1124 211840
        case DISTEXT:
1125 211840
            if (state->extra) {
1126 209406
                NEEDBITS(state->extra);
1127 209279
                state->offset += BITS(state->extra);
1128 209279
                DROPBITS(state->extra);
1129 209279
                state->back += state->extra;
1130 209279
            }
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 211713
            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
1139 211713
            state->mode = MATCH;
1140
                /* fallthrough */
1141 233558
        case MATCH:
1142 233558
            if (left == 0) goto inf_leave;
1143 219212
            copy = out - left;
1144 219212
            if (state->offset > copy) {         /* copy from window */
1145 80534
                copy = state->offset - copy;
1146 80534
                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 0
                    }
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 80534
                if (copy > state->wnext) {
1167 11412
                    copy -= state->wnext;
1168 11412
                    from = state->window + (state->wsize - copy);
1169 11412
                }
1170 69122
                else
1171 69122
                    from = state->window + (state->wnext - copy);
1172 80534
                if (copy > state->length) copy = state->length;
1173 80534
            }
1174 138678
            else {                              /* copy from output */
1175 138678
                from = put - state->offset;
1176 138678
                copy = state->length;
1177 138678
            }
1178 219212
            if (copy > left) copy = left;
1179 219212
            left -= copy;
1180 219212
            state->length -= copy;
1181 1766981
            do {
1182 1766981
                *put++ = *from++;
1183 1766981
            } while (--copy);
1184 219212
            if (state->length == 0) state->mode = LEN;
1185 219212
            break;
1186 374156
        case LIT:
1187 374156
            if (left == 0) goto inf_leave;
1188 371222
            *put++ = (unsigned char)(state->length);
1189 371222
            left--;
1190 371222
            state->mode = LEN;
1191 371222
            break;
1192 713
        case CHECK:
1193 713
            if (state->wrap) {
1194 713
                NEEDBITS(32);
1195 677
                out -= left;
1196 677
                strm->total_out += out;
1197 677
                state->total += out;
1198 677
                if ((state->wrap & 4) && out)
1199 566
                    strm->adler = state->check =
1200 566
                        UPDATE_CHECK(state->check, put - out, out);
1201 677
                out = left;
1202 677
                if ((state->wrap & 4) && (
1203 677
#ifdef GUNZIP
1204 677
                     state->flags ? hold :
1205 677
#endif
1206 677
                     ZSWAP32(hold)) != state->check) {
1207 0
                    strm->msg = (z_const char *)"incorrect data check";
1208 0
                    state->mode = BAD;
1209 0
                    break;
1210 0
                }
1211 677
                INITBITS();
1212 677
                Tracev((stderr, "inflate:   check matches trailer\n"));
1213 677
            }
1214 677
#ifdef GUNZIP
1215 677
            state->mode = LENGTH;
1216
                /* fallthrough */
1217 683
        case LENGTH:
1218 683
            if (state->wrap && state->flags) {
1219 683
                NEEDBITS(32);
1220 677
                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 0
                }
1225 677
                INITBITS();
1226 677
                Tracev((stderr, "inflate:   length matches trailer\n"));
1227 677
            }
1228 677
#endif
1229 677
            state->mode = DONE;
1230
                /* fallthrough */
1231 1064
        case DONE:
1232 1064
            ret = Z_STREAM_END;
1233 1064
            goto inf_leave;
1234 50
        case BAD:
1235 50
            ret = Z_DATA_ERROR;
1236 50
            goto inf_leave;
1237 0
        case MEM:
1238 0
            return Z_MEM_ERROR;
1239 0
        case SYNC:
1240
                /* fallthrough */
1241 0
        default:
1242 0
            return Z_STREAM_ERROR;
1243 1043287
        }
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 26794
  inf_leave:
1252 26794
    RESTORE();
1253 26794
    if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
1254 1396
            (state->mode < CHECK || flush != Z_FINISH)))
1255 25836
        if (updatewindow(strm, strm->next_out, out - strm->avail_out)) {
1256 0
            state->mode = MEM;
1257 0
            return Z_MEM_ERROR;
1258 0
        }
1259 26794
    in -= strm->avail_in;
1260 26794
    out -= strm->avail_out;
1261 26794
    strm->total_in += in;
1262 26794
    strm->total_out += out;
1263 26794
    state->total += out;
1264 26796
    if ((state->wrap & 4) && out)
1265 13208
        strm->adler = state->check =
1266 13208
            UPDATE_CHECK(state->check, strm->next_out - out, out);
1267 26794
    strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
1268 26794
                      (state->mode == TYPE ? 128 : 0) +
1269 26796
                      (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
1270 26794
    if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1271 9254
        ret = Z_BUF_ERROR;
1272 26794
    return ret;
1273 26794
}
1274
1275 937
int ZEXPORT inflateEnd(z_streamp strm) {
1276 937
    struct inflate_state FAR *state;
1277 937
    if (inflateStateCheck(strm))
1278 0
        return Z_STREAM_ERROR;
1279 937
    state = (struct inflate_state FAR *)strm->state;
1280 937
    if (state->window != Z_NULL) ZFREE(strm, state->window);
1281 937
    ZFREE(strm, strm->state);
1282 937
    strm->state = Z_NULL;
1283 937
    Tracev((stderr, "inflate: end\n"));
1284 937
    return Z_OK;
1285 937
}
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 */