OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [inflate.c] - Blame information for rev 745

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.