Coverage Report

Created: 2023-12-08 06:59

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