1 /* inflate.c -- zlib decompression
2 * Copyright (C) 1995-2005 Mark Adler
3 * For conditions of distribution and use, see copyright notice in zlib.h
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
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
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
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
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
57 * 1.2.beta5 1 Jan 2003
58 * - Improved inflateBack() interface to allow the caller to provide initial
60 * - Fixed stored blocks bug in inflateBack()
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 *
69 * 1.2.beta7 27 Jan 2003
70 * - Changed many types to unsigned or unsigned short to avoid warnings
71 * - Added inflateCopy() function
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()
80 * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
94 /* function prototypes */
95 local void fixedtables OF((struct inflate_state FAR *state));
96 local int updatewindow OF((z_streamp strm, unsigned out));
98 void makefixed OF((void));
100 local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
103 int ZEXPORT inflateReset(strm)
106 struct inflate_state FAR *state;
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;
112 strm->adler = 1; /* to support ill-conceived Java test suite */
116 state->dmax = 32768U;
117 state->max_window_dist = 0;
118 state->dist_window_tail = 0;
119 state->dist_window = (unsigned short*)realloc(state->dist_window, state->dmax * sizeof(unsigned short));
120 memset(state->dist_window, 0, state->dmax * sizeof(unsigned short));
121 state->head = Z_NULL;
127 state->lencode = state->distcode = state->next = state->codes;
128 Tracev((stderr, "inflate: reset\n"));
132 int ZEXPORT inflatePrime(strm, bits, value)
137 struct inflate_state FAR *state;
139 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
140 state = (struct inflate_state FAR *)strm->state;
141 if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
142 value &= (1L << bits) - 1;
143 state->hold += value << state->bits;
148 int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
154 struct inflate_state FAR *state;
156 if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
157 stream_size != (int)(sizeof(z_stream)))
158 return Z_VERSION_ERROR;
159 if (strm == Z_NULL) return Z_STREAM_ERROR;
160 strm->msg = Z_NULL; /* in case we return an error */
161 if (strm->zalloc == (alloc_func)0) {
162 strm->zalloc = zcalloc;
163 strm->opaque = (voidpf)0;
165 if (strm->zfree == (free_func)0) strm->zfree = zcfree;
166 state = (struct inflate_state FAR *)
167 ZALLOC(strm, 1, sizeof(struct inflate_state));
168 if (state == Z_NULL) return Z_MEM_ERROR;
169 Tracev((stderr, "inflate: allocated\n"));
170 strm->state = (struct internal_state FAR *)state;
171 if (windowBits < 0) {
173 windowBits = -windowBits;
176 state->wrap = (windowBits >> 4) + 1;
178 if (windowBits < 48) windowBits &= 15;
181 if (windowBits < 8 || windowBits > 15) {
183 strm->state = Z_NULL;
184 return Z_STREAM_ERROR;
186 state->wbits = (unsigned)windowBits;
187 state->window = Z_NULL;
188 state->dist_window = NULL;
189 return inflateReset(strm);
192 int ZEXPORT inflateInit_(strm, version, stream_size)
197 return inflateInit2_(strm, DEF_WBITS, version, stream_size);
201 Return state with length and distance decoding tables and index sizes set to
202 fixed code decoding. Normally this returns fixed tables from inffixed.h.
203 If BUILDFIXED is defined, then instead this routine builds the tables the
204 first time it's called, and returns those tables the first time and
205 thereafter. This reduces the size of the code by about 2K bytes, in
206 exchange for a little execution time. However, BUILDFIXED should not be
207 used for threaded applications, since the rewriting of the tables and virgin
208 may not be thread-safe.
210 local void fixedtables(state)
211 struct inflate_state FAR *state;
214 static int virgin = 1;
215 static code *lenfix, *distfix;
216 static code fixed[544];
218 /* build fixed huffman tables if first call (may not be thread safe) */
223 /* literal/length table */
225 while (sym < 144) state->lens[sym++] = 8;
226 while (sym < 256) state->lens[sym++] = 9;
227 while (sym < 280) state->lens[sym++] = 7;
228 while (sym < 288) state->lens[sym++] = 8;
232 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
236 while (sym < 32) state->lens[sym++] = 5;
239 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
241 /* do this just once */
244 #else /* !BUILDFIXED */
245 # include "inffixed.h"
246 #endif /* BUILDFIXED */
247 state->lencode = lenfix;
249 state->distcode = distfix;
257 Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also
258 defines BUILDFIXED, so the tables are built on the fly. makefixed() writes
259 those tables to stdout, which would be piped to inffixed.h. A small program
260 can simply call makefixed to do this:
262 void makefixed(void);
270 Then that can be linked with zlib built with MAKEFIXED defined and run:
277 struct inflate_state state;
280 puts(" /* inffixed.h -- table for decoding fixed codes");
281 puts(" * Generated automatically by makefixed().");
284 puts(" /* WARNING: this file should *not* be used by applications.");
285 puts(" It is part of the implementation of this library and is");
286 puts(" subject to change. Applications should only use zlib.h.");
290 printf(" static const code lenfix[%u] = {", size);
293 if ((low % 7) == 0) printf("\n ");
294 printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
295 state.lencode[low].val);
296 if (++low == size) break;
301 printf("\n static const code distfix[%u] = {", size);
304 if ((low % 6) == 0) printf("\n ");
305 printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
306 state.distcode[low].val);
307 if (++low == size) break;
312 #endif /* MAKEFIXED */
315 Update the window with the last wsize (normally 32K) bytes written before
316 returning. If window does not exist yet, create it. This is only called
317 when a window is already in use, or when output has been written during this
318 inflate call, but the end of the deflate stream has not been reached yet.
319 It is also called to create a window for dictionary data when a dictionary
322 Providing output buffers larger than 32K to inflate() should provide a speed
323 advantage, since only the last 32K of output is copied to the sliding window
324 upon return from inflate(), and since all distances after the first 32K of
325 output will fall in the output data, making match copies simpler and faster.
326 The advantage may be dependent on the size of the processor's data caches.
328 local int updatewindow(strm, out)
332 struct inflate_state FAR *state;
335 state = (struct inflate_state FAR *)strm->state;
337 /* if it hasn't been done already, allocate space for the window */
338 if (state->window == Z_NULL) {
339 state->window = (unsigned char FAR *)
340 ZALLOC(strm, 1U << state->wbits,
341 sizeof(unsigned char));
342 if (state->window == Z_NULL) return 1;
345 /* if window not in use yet, initialize */
346 if (state->wsize == 0) {
347 state->wsize = 1U << state->wbits;
352 /* copy state->wsize or less output bytes into the circular window */
353 copy = out - strm->avail_out;
354 if (copy >= state->wsize) {
355 zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
357 state->whave = state->wsize;
360 dist = state->wsize - state->write;
361 if (dist > copy) dist = copy;
362 zmemcpy(state->window + state->write, strm->next_out - copy, dist);
365 zmemcpy(state->window, strm->next_out - copy, copy);
367 state->whave = state->wsize;
370 state->write += dist;
371 if (state->write == state->wsize) state->write = 0;
372 if (state->whave < state->wsize) state->whave += dist;
378 /* Macros for inflate(): */
380 /* check function to use adler32() for zlib or crc32() for gzip */
382 # define UPDATE(check, buf, len) \
383 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
385 # define UPDATE(check, buf, len) adler32(check, buf, len)
388 /* check macros for header crc */
390 # define CRC2(check, word) \
392 hbuf[0] = (unsigned char)(word); \
393 hbuf[1] = (unsigned char)((word) >> 8); \
394 check = crc32(check, hbuf, 2); \
397 # define CRC4(check, word) \
399 hbuf[0] = (unsigned char)(word); \
400 hbuf[1] = (unsigned char)((word) >> 8); \
401 hbuf[2] = (unsigned char)((word) >> 16); \
402 hbuf[3] = (unsigned char)((word) >> 24); \
403 check = crc32(check, hbuf, 4); \
407 /* Load registers with state in inflate() for speed */
410 put = strm->next_out; \
411 left = strm->avail_out; \
412 next = strm->next_in; \
413 have = strm->avail_in; \
414 hold = state->hold; \
415 bits = state->bits; \
418 /* Restore state from registers in inflate() */
421 strm->next_out = put; \
422 strm->avail_out = left; \
423 strm->next_in = next; \
424 strm->avail_in = have; \
425 state->hold = hold; \
426 state->bits = bits; \
429 /* Clear the input bit accumulator */
436 /* Get a byte of input into the bit accumulator, or return from inflate()
437 if there is no input available. */
440 if (have == 0) goto inf_leave; \
442 hold += (unsigned long)(*next++) << bits; \
446 /* Assure that there are at least n bits in the bit accumulator. If there is
447 not enough available input to do that, then return from inflate(). */
448 #define NEEDBITS(n) \
450 while (bits < (unsigned)(n)) \
454 /* Return the low n bits of the bit accumulator (n < 16) */
456 ((unsigned)hold & ((1U << (n)) - 1))
458 /* Remove n bits from the bit accumulator */
459 #define DROPBITS(n) \
462 bits -= (unsigned)(n); \
465 /* Remove zero to seven bits as needed to go to a byte boundary */
472 /* Reverse the bytes in a 32-bit value */
474 ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
475 (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
478 inflate() uses a state machine to process as much input data and generate as
479 much output data as possible before returning. The state machine is
480 structured roughly as follows:
482 for (;;) switch (state) {
485 if (not enough input data or output space to make progress)
487 ... make progress ...
493 so when inflate() is called again, the same case is attempted again, and
494 if the appropriate resources are provided, the machine proceeds to the
495 next state. The NEEDBITS() macro is usually the way the state evaluates
496 whether it can proceed or should return. NEEDBITS() does the return if
497 the requested bits are not available. The typical use of the BITS macros
501 ... do something with BITS(n) ...
504 where NEEDBITS(n) either returns from inflate() if there isn't enough
505 input left to load n bits into the accumulator, or it continues. BITS(n)
506 gives the low n bits in the accumulator. When done, DROPBITS(n) drops
507 the low n bits off the accumulator. INITBITS() clears the accumulator
508 and sets the number of available bits to zero. BYTEBITS() discards just
509 enough bits to put the accumulator on a byte boundary. After BYTEBITS()
510 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
512 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
513 if there is no input available. The decoding of variable length codes uses
514 PULLBYTE() directly in order to pull just enough bytes to decode the next
517 Some states loop until they get enough input, making sure that enough
518 state information is maintained to continue the loop where it left off
519 if NEEDBITS() returns in the loop. For example, want, need, and keep
520 would all have to actually be part of the saved state in case NEEDBITS()
524 while (want < need) {
526 keep[want++] = BITS(n);
532 As shown above, if the next state is also the next case, then the break
535 A state may also return if there is not enough output space available to
536 complete that state. Those states are copying stored data, writing a
537 literal byte, and copying a matching string.
539 When returning, a "goto inf_leave" is used to update the total counters,
540 update the check value, and determine whether any progress has been made
541 during that inflate() call in order to return the proper return code.
542 Progress is defined as a change in either strm->avail_in or strm->avail_out.
543 When there is a window, goto inf_leave will update the window with the last
544 output written. If a goto inf_leave occurs in the middle of decompression
545 and there is no window currently, goto inf_leave will create one and copy
546 output to the window for the next call of inflate().
548 In this implementation, the flush parameter of inflate() only affects the
549 return code (per zlib.h). inflate() always writes as much as possible to
550 strm->next_out, given the space available and the provided input--the effect
551 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
552 the allocation of and copying into a sliding window until necessary, which
553 provides the effect documented in zlib.h for Z_FINISH when the entire input
554 stream available. So the only thing the flush parameter actually does is:
555 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
556 will return Z_BUF_ERROR if it has not reached the end of the stream.
559 int ZEXPORT inflate(strm, flush)
563 struct inflate_state FAR *state;
564 unsigned char FAR *next; /* next input */
565 unsigned char FAR *put; /* next output */
566 unsigned have, left; /* available input and output */
567 unsigned long hold; /* bit buffer */
568 unsigned bits; /* bits in bit buffer */
569 unsigned in, out; /* save starting available input and output */
570 unsigned copy; /* number of stored or match bytes to copy */
571 unsigned char FAR *from; /* where to copy match bytes from */
572 code this; /* current decoding table entry */
573 code last; /* parent table entry */
574 unsigned len; /* length to copy for repeats, bits to drop */
575 int ret; /* return code */
577 unsigned char hbuf[4]; /* buffer for gzip header crc calculation */
579 static const unsigned short order[19] = /* permutation of code lengths */
580 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
582 if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
583 (strm->next_in == Z_NULL && strm->avail_in != 0))
584 return Z_STREAM_ERROR;
586 state = (struct inflate_state FAR *)strm->state;
587 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
593 switch (state->mode) {
595 if (state->wrap == 0) {
596 state->mode = TYPEDO;
601 if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
602 state->check = crc32(0L, Z_NULL, 0);
603 CRC2(state->check, hold);
608 state->flags = 0; /* expect zlib header */
609 if (state->head != Z_NULL)
610 state->head->done = -1;
611 if (!(state->wrap & 1) || /* check if zlib header allowed */
615 ((BITS(8) << 8) + (hold >> 8)) % 31) {
616 strm->msg = (char *)"incorrect header check";
620 if (BITS(4) != Z_DEFLATED) {
621 strm->msg = (char *)"unknown compression method";
627 if (len > state->wbits) {
628 strm->msg = (char *)"invalid window size";
632 state->dmax = 1U << len;
633 state->max_window_dist = 0;
634 state->dist_window_tail = 0;
635 state->dist_window = (unsigned short*)realloc(state->dist_window, state->dmax * sizeof(unsigned short));
636 memset(state->dist_window, 0, state->dmax * sizeof(unsigned short));
637 Tracev((stderr, "inflate: zlib header ok\n"));
638 strm->adler = state->check = adler32(0L, Z_NULL, 0);
639 state->mode = hold & 0x200 ? DICTID : TYPE;
645 state->flags = (int)(hold);
646 if ((state->flags & 0xff) != Z_DEFLATED) {
647 strm->msg = (char *)"unknown compression method";
651 if (state->flags & 0xe000) {
652 strm->msg = (char *)"unknown header flags set";
656 if (state->head != Z_NULL)
657 state->head->text = (int)((hold >> 8) & 1);
658 if (state->flags & 0x0200) CRC2(state->check, hold);
663 if (state->head != Z_NULL)
664 state->head->time = hold;
665 if (state->flags & 0x0200) CRC4(state->check, hold);
670 if (state->head != Z_NULL) {
671 state->head->xflags = (int)(hold & 0xff);
672 state->head->os = (int)(hold >> 8);
674 if (state->flags & 0x0200) CRC2(state->check, hold);
678 if (state->flags & 0x0400) {
680 state->length = (unsigned)(hold);
681 if (state->head != Z_NULL)
682 state->head->extra_len = (unsigned)hold;
683 if (state->flags & 0x0200) CRC2(state->check, hold);
686 else if (state->head != Z_NULL)
687 state->head->extra = Z_NULL;
690 if (state->flags & 0x0400) {
691 copy = state->length;
692 if (copy > have) copy = have;
694 if (state->head != Z_NULL &&
695 state->head->extra != Z_NULL) {
696 len = state->head->extra_len - state->length;
697 zmemcpy(state->head->extra + len, next,
698 len + copy > state->head->extra_max ?
699 state->head->extra_max - len : copy);
701 if (state->flags & 0x0200)
702 state->check = crc32(state->check, next, copy);
705 state->length -= copy;
707 if (state->length) goto inf_leave;
712 if (state->flags & 0x0800) {
713 if (have == 0) goto inf_leave;
716 len = (unsigned)(next[copy++]);
717 if (state->head != Z_NULL &&
718 state->head->name != Z_NULL &&
719 state->length < state->head->name_max)
720 state->head->name[state->length++] = len;
721 } while (len && copy < have);
722 if (state->flags & 0x0200)
723 state->check = crc32(state->check, next, copy);
726 if (len) goto inf_leave;
728 else if (state->head != Z_NULL)
729 state->head->name = Z_NULL;
731 state->mode = COMMENT;
733 if (state->flags & 0x1000) {
734 if (have == 0) goto inf_leave;
737 len = (unsigned)(next[copy++]);
738 if (state->head != Z_NULL &&
739 state->head->comment != Z_NULL &&
740 state->length < state->head->comm_max)
741 state->head->comment[state->length++] = len;
742 } while (len && copy < have);
743 if (state->flags & 0x0200)
744 state->check = crc32(state->check, next, copy);
747 if (len) goto inf_leave;
749 else if (state->head != Z_NULL)
750 state->head->comment = Z_NULL;
753 if (state->flags & 0x0200) {
755 if (hold != (state->check & 0xffff)) {
756 strm->msg = (char *)"header crc mismatch";
762 if (state->head != Z_NULL) {
763 state->head->hcrc = (int)((state->flags >> 9) & 1);
764 state->head->done = 1;
766 strm->adler = state->check = crc32(0L, Z_NULL, 0);
772 strm->adler = state->check = REVERSE(hold);
776 if (state->havedict == 0) {
780 strm->adler = state->check = adler32(0L, Z_NULL, 0);
783 if (flush == Z_BLOCK) goto inf_leave;
791 state->last = BITS(1);
794 case 0: /* stored block */
795 Tracev((stderr, "inflate: stored block%s\n",
796 state->last ? " (last)" : ""));
797 state->mode = STORED;
799 case 1: /* fixed block */
801 Tracev((stderr, "inflate: fixed codes block%s\n",
802 state->last ? " (last)" : ""));
803 state->mode = LEN; /* decode codes */
805 case 2: /* dynamic block */
806 Tracev((stderr, "inflate: dynamic codes block%s\n",
807 state->last ? " (last)" : ""));
811 strm->msg = (char *)"invalid block type";
817 BYTEBITS(); /* go to byte boundary */
819 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
820 strm->msg = (char *)"invalid stored block lengths";
824 state->length = (unsigned)hold & 0xffff;
825 Tracev((stderr, "inflate: stored length %u\n",
830 copy = state->length;
832 if (copy > have) copy = have;
833 if (copy > left) copy = left;
834 if (copy == 0) goto inf_leave;
835 zmemcpy(put, next, copy);
840 state->length -= copy;
843 Tracev((stderr, "inflate: stored end\n"));
848 state->nlen = BITS(5) + 257;
850 state->ndist = BITS(5) + 1;
852 state->ncode = BITS(4) + 4;
854 #ifndef PKZIP_BUG_WORKAROUND
855 if (state->nlen > 286 || state->ndist > 30) {
856 strm->msg = (char *)"too many length or distance symbols";
861 Tracev((stderr, "inflate: table sizes ok\n"));
863 state->mode = LENLENS;
865 while (state->have < state->ncode) {
867 state->lens[order[state->have++]] = (unsigned short)BITS(3);
870 while (state->have < 19)
871 state->lens[order[state->have++]] = 0;
872 state->next = state->codes;
873 state->lencode = (code const FAR *)(state->next);
875 ret = inflate_table(CODES, state->lens, 19, &(state->next),
876 &(state->lenbits), state->work);
878 strm->msg = (char *)"invalid code lengths set";
882 Tracev((stderr, "inflate: code lengths ok\n"));
884 state->mode = CODELENS;
886 while (state->have < state->nlen + state->ndist) {
888 this = state->lencode[BITS(state->lenbits)];
889 if ((unsigned)(this.bits) <= bits) break;
895 state->lens[state->have++] = this.val;
898 if (this.val == 16) {
899 NEEDBITS(this.bits + 2);
901 if (state->have == 0) {
902 strm->msg = (char *)"invalid bit length repeat";
906 len = state->lens[state->have - 1];
910 else if (this.val == 17) {
911 NEEDBITS(this.bits + 3);
918 NEEDBITS(this.bits + 7);
924 if (state->have + copy > state->nlen + state->ndist) {
925 strm->msg = (char *)"invalid bit length repeat";
930 state->lens[state->have++] = (unsigned short)len;
934 /* handle error breaks in while */
935 if (state->mode == BAD) break;
937 /* build code tables */
938 state->next = state->codes;
939 state->lencode = (code const FAR *)(state->next);
941 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
942 &(state->lenbits), state->work);
944 strm->msg = (char *)"invalid literal/lengths set";
948 state->distcode = (code const FAR *)(state->next);
950 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
951 &(state->next), &(state->distbits), state->work);
953 strm->msg = (char *)"invalid distances set";
957 Tracev((stderr, "inflate: codes ok\n"));
960 if (have >= 6 && left >= 258) {
962 inflate_fast(strm, out);
967 this = state->lencode[BITS(state->lenbits)];
968 if ((unsigned)(this.bits) <= bits) break;
971 if (this.op && (this.op & 0xf0) == 0) {
974 this = state->lencode[last.val +
975 (BITS(last.bits + last.op) >> last.bits)];
976 if ((unsigned)(last.bits + this.bits) <= bits) break;
982 state->length = (unsigned)this.val;
983 if ((int)(this.op) == 0) {
984 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
985 "inflate: literal '%c'\n" :
986 "inflate: literal 0x%02x\n", this.val));
991 Tracevv((stderr, "inflate: end of block\n"));
996 strm->msg = (char *)"invalid literal/length code";
1000 state->extra = (unsigned)(this.op) & 15;
1001 state->mode = LENEXT;
1004 NEEDBITS(state->extra);
1005 state->length += BITS(state->extra);
1006 DROPBITS(state->extra);
1008 Tracevv((stderr, "inflate: length %u\n", state->length));
1012 this = state->distcode[BITS(state->distbits)];
1013 if ((unsigned)(this.bits) <= bits) break;
1016 if ((this.op & 0xf0) == 0) {
1019 this = state->distcode[last.val +
1020 (BITS(last.bits + last.op) >> last.bits)];
1021 if ((unsigned)(last.bits + this.bits) <= bits) break;
1024 DROPBITS(last.bits);
1026 DROPBITS(this.bits);
1028 strm->msg = (char *)"invalid distance code";
1032 state->offset = (unsigned)this.val;
1033 state->extra = (unsigned)(this.op) & 15;
1034 state->mode = DISTEXT;
1037 NEEDBITS(state->extra);
1038 state->offset += BITS(state->extra);
1039 DROPBITS(state->extra);
1041 #ifdef INFLATE_STRICT
1042 if (state->offset > state->dmax) {
1043 strm->msg = (char *)"invalid distance too far back";
1048 if (state->offset > state->whave + out - left) {
1049 strm->msg = (char *)"invalid distance too far back";
1053 Tracevv((stderr, "inflate: distance %u\n", state->offset));
1054 state->mode = MATCH;
1056 if (left == 0) goto inf_leave;
1058 if (state->offset > copy) { /* copy from window */
1059 copy = state->offset - copy;
1060 if (copy > state->write) {
1061 copy -= state->write;
1062 from = state->window + (state->wsize - copy);
1065 from = state->window + (state->write - copy);
1066 if (copy > state->length) copy = state->length;
1068 else { /* copy from output */
1069 from = put - state->offset;
1070 copy = state->length;
1072 if (copy > left) copy = left;
1074 state->length -= copy;
1078 if (state->length == 0) state->mode = LEN;
1081 if (left == 0) goto inf_leave;
1082 *put++ = (unsigned char)(state->length);
1090 strm->total_out += out;
1091 state->total += out;
1093 strm->adler = state->check =
1094 UPDATE(state->check, put - out, out);
1098 state->flags ? hold :
1100 REVERSE(hold)) != state->check) {
1101 strm->msg = (char *)"incorrect data check";
1106 Tracev((stderr, "inflate: check matches trailer\n"));
1109 state->mode = LENGTH;
1111 if (state->wrap && state->flags) {
1113 if (hold != (state->total & 0xffffffffUL)) {
1114 strm->msg = (char *)"incorrect length check";
1119 Tracev((stderr, "inflate: length matches trailer\n"));
1133 return Z_STREAM_ERROR;
1137 Return from inflate(), updating the total counts and the check value.
1138 If there was no progress during the inflate() call, return a buffer
1139 error. Call updatewindow() to create and/or update the window state.
1140 Note: a memory error from inflate() is non-recoverable.
1144 if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
1145 if (updatewindow(strm, out)) {
1149 in -= strm->avail_in;
1150 out -= strm->avail_out;
1151 strm->total_in += in;
1152 strm->total_out += out;
1153 state->total += out;
1154 if (state->wrap && out)
1155 strm->adler = state->check =
1156 UPDATE(state->check, strm->next_out - out, out);
1157 strm->data_type = state->bits + (state->last ? 64 : 0) +
1158 (state->mode == TYPE ? 128 : 0);
1159 if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1164 int ZEXPORT inflate_zr(strm, flush)
1168 struct inflate_state FAR *state;
1169 unsigned char FAR *next; /* next input */
1170 unsigned char FAR *put; /* next output */
1171 unsigned have, left; /* available input and output */
1172 unsigned long hold; /* bit buffer */
1173 unsigned bits; /* bits in bit buffer */
1174 unsigned in, out; /* save starting available input and output */
1175 unsigned copy; /* number of stored or match bytes to copy */
1176 unsigned char FAR *from; /* where to copy match bytes from */
1177 code this; /* current decoding table entry */
1178 code last; /* parent table entry */
1179 unsigned len; /* length to copy for repeats, bits to drop */
1180 int ret; /* return code */
1182 unsigned char hbuf[4]; /* buffer for gzip header crc calculation */
1184 static const unsigned short order[19] = /* permutation of code lengths */
1185 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
1187 if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
1188 (strm->next_in == Z_NULL && strm->avail_in != 0))
1189 return Z_STREAM_ERROR;
1191 state = (struct inflate_state FAR *)strm->state;
1192 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
1198 switch (state->mode) {
1200 if (state->wrap == 0) {
1201 state->mode = TYPEDO;
1206 if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
1207 state->check = crc32(0L, Z_NULL, 0);
1208 CRC2(state->check, hold);
1210 state->mode = FLAGS;
1213 state->flags = 0; /* expect zlib header */
1214 if (state->head != Z_NULL)
1215 state->head->done = -1;
1216 if (!(state->wrap & 1) || /* check if zlib header allowed */
1220 ((BITS(8) << 8) + (hold >> 8)) % 31) {
1221 strm->msg = (char *)"incorrect header check";
1225 if (BITS(4) != Z_DEFLATED) {
1226 strm->msg = (char *)"unknown compression method";
1232 if (len > state->wbits) {
1233 strm->msg = (char *)"invalid window size";
1237 state->dmax = 1U << len;
1238 state->max_window_dist = 0;
1239 state->dist_window_tail = 0;
1240 state->dist_window = (unsigned short*)realloc(state->dist_window, state->dmax * sizeof(unsigned short));
1241 memset(state->dist_window, 0, state->dmax * sizeof(unsigned short));
1242 Tracev((stderr, "inflate: zlib header ok\n"));
1243 strm->adler = state->check = adler32(0L, Z_NULL, 0);
1244 state->mode = hold & 0x200 ? DICTID : TYPE;
1250 state->flags = (int)(hold);
1251 if ((state->flags & 0xff) != Z_DEFLATED) {
1252 strm->msg = (char *)"unknown compression method";
1256 if (state->flags & 0xe000) {
1257 strm->msg = (char *)"unknown header flags set";
1261 if (state->head != Z_NULL)
1262 state->head->text = (int)((hold >> 8) & 1);
1263 if (state->flags & 0x0200) CRC2(state->check, hold);
1268 if (state->head != Z_NULL)
1269 state->head->time = hold;
1270 if (state->flags & 0x0200) CRC4(state->check, hold);
1275 if (state->head != Z_NULL) {
1276 state->head->xflags = (int)(hold & 0xff);
1277 state->head->os = (int)(hold >> 8);
1279 if (state->flags & 0x0200) CRC2(state->check, hold);
1281 state->mode = EXLEN;
1283 if (state->flags & 0x0400) {
1285 state->length = (unsigned)(hold);
1286 if (state->head != Z_NULL)
1287 state->head->extra_len = (unsigned)hold;
1288 if (state->flags & 0x0200) CRC2(state->check, hold);
1291 else if (state->head != Z_NULL)
1292 state->head->extra = Z_NULL;
1293 state->mode = EXTRA;
1295 if (state->flags & 0x0400) {
1296 copy = state->length;
1297 if (copy > have) copy = have;
1299 if (state->head != Z_NULL &&
1300 state->head->extra != Z_NULL) {
1301 len = state->head->extra_len - state->length;
1302 zmemcpy(state->head->extra + len, next,
1303 len + copy > state->head->extra_max ?
1304 state->head->extra_max - len : copy);
1306 if (state->flags & 0x0200)
1307 state->check = crc32(state->check, next, copy);
1310 state->length -= copy;
1312 if (state->length) goto inf_leave;
1317 if (state->flags & 0x0800) {
1318 if (have == 0) goto inf_leave;
1321 len = (unsigned)(next[copy++]);
1322 if (state->head != Z_NULL &&
1323 state->head->name != Z_NULL &&
1324 state->length < state->head->name_max)
1325 state->head->name[state->length++] = len;
1326 } while (len && copy < have);
1327 if (state->flags & 0x0200)
1328 state->check = crc32(state->check, next, copy);
1331 if (len) goto inf_leave;
1333 else if (state->head != Z_NULL)
1334 state->head->name = Z_NULL;
1336 state->mode = COMMENT;
1338 if (state->flags & 0x1000) {
1339 if (have == 0) goto inf_leave;
1342 len = (unsigned)(next[copy++]);
1343 if (state->head != Z_NULL &&
1344 state->head->comment != Z_NULL &&
1345 state->length < state->head->comm_max)
1346 state->head->comment[state->length++] = len;
1347 } while (len && copy < have);
1348 if (state->flags & 0x0200)
1349 state->check = crc32(state->check, next, copy);
1352 if (len) goto inf_leave;
1354 else if (state->head != Z_NULL)
1355 state->head->comment = Z_NULL;
1358 if (state->flags & 0x0200) {
1360 if (hold != (state->check & 0xffff)) {
1361 strm->msg = (char *)"header crc mismatch";
1367 if (state->head != Z_NULL) {
1368 state->head->hcrc = (int)((state->flags >> 9) & 1);
1369 state->head->done = 1;
1371 strm->adler = state->check = crc32(0L, Z_NULL, 0);
1377 strm->adler = state->check = REVERSE(hold);
1381 if (state->havedict == 0) {
1385 strm->adler = state->check = adler32(0L, Z_NULL, 0);
1388 if (flush == Z_BLOCK) goto inf_leave;
1392 state->mode = CHECK;
1396 state->last = BITS(1);
1399 case 0: /* stored block */
1400 Tracev((stderr, "inflate: stored block%s\n",
1401 state->last ? " (last)" : ""));
1402 state->mode = STORED;
1404 case 1: /* fixed block */
1406 Tracev((stderr, "inflate: fixed codes block%s\n",
1407 state->last ? " (last)" : ""));
1408 state->mode = LEN; /* decode codes */
1410 case 2: /* dynamic block */
1411 Tracev((stderr, "inflate: dynamic codes block%s\n",
1412 state->last ? " (last)" : ""));
1413 state->mode = TABLE;
1416 strm->msg = (char *)"invalid block type";
1422 BYTEBITS(); /* go to byte boundary */
1424 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
1425 strm->msg = (char *)"invalid stored block lengths";
1429 state->length = (unsigned)hold & 0xffff;
1430 Tracev((stderr, "inflate: stored length %u\n",
1435 copy = state->length;
1437 if (copy > have) copy = have;
1438 if (copy > left) copy = left;
1439 if (copy == 0) goto inf_leave;
1440 zmemcpy(put, next, copy);
1445 state->length -= copy;
1448 Tracev((stderr, "inflate: stored end\n"));
1453 state->nlen = BITS(5) + 257;
1455 state->ndist = BITS(5) + 1;
1457 state->ncode = BITS(4) + 4;
1459 #ifndef PKZIP_BUG_WORKAROUND
1460 if (state->nlen > 286 || state->ndist > 30) {
1461 strm->msg = (char *)"too many length or distance symbols";
1466 Tracev((stderr, "inflate: table sizes ok\n"));
1468 state->mode = LENLENS;
1470 while (state->have < state->ncode) {
1472 state->lens[order[state->have++]] = (unsigned short)BITS(3);
1475 while (state->have < 19)
1476 state->lens[order[state->have++]] = 0;
1477 state->next = state->codes;
1478 state->lencode = (code const FAR *)(state->next);
1480 ret = inflate_table(CODES, state->lens, 19, &(state->next),
1481 &(state->lenbits), state->work);
1483 strm->msg = (char *)"invalid code lengths set";
1487 Tracev((stderr, "inflate: code lengths ok\n"));
1489 state->mode = CODELENS;
1491 while (state->have < state->nlen + state->ndist) {
1493 this = state->lencode[BITS(state->lenbits)];
1494 if ((unsigned)(this.bits) <= bits) break;
1497 if (this.val < 16) {
1498 NEEDBITS(this.bits);
1499 DROPBITS(this.bits);
1500 state->lens[state->have++] = this.val;
1503 if (this.val == 16) {
1504 NEEDBITS(this.bits + 2);
1505 DROPBITS(this.bits);
1506 if (state->have == 0) {
1507 strm->msg = (char *)"invalid bit length repeat";
1511 len = state->lens[state->have - 1];
1515 else if (this.val == 17) {
1516 NEEDBITS(this.bits + 3);
1517 DROPBITS(this.bits);
1523 NEEDBITS(this.bits + 7);
1524 DROPBITS(this.bits);
1526 copy = 11 + BITS(7);
1529 if (state->have + copy > state->nlen + state->ndist) {
1530 strm->msg = (char *)"invalid bit length repeat";
1535 state->lens[state->have++] = (unsigned short)len;
1539 /* handle error breaks in while */
1540 if (state->mode == BAD) break;
1542 /* build code tables */
1543 state->next = state->codes;
1544 state->lencode = (code const FAR *)(state->next);
1546 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1547 &(state->lenbits), state->work);
1549 strm->msg = (char *)"invalid literal/lengths set";
1553 state->distcode = (code const FAR *)(state->next);
1554 state->distbits = 6;
1555 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1556 &(state->next), &(state->distbits), state->work);
1558 strm->msg = (char *)"invalid distances set";
1562 Tracev((stderr, "inflate: codes ok\n"));
1565 if (have >= 6 && left >= 258) {
1567 inflate_fast_zr(strm, out);
1572 this = state->lencode[BITS(state->lenbits)];
1573 if ((unsigned)(this.bits) <= bits) break;
1576 if (this.op && (this.op & 0xf0) == 0) {
1579 this = state->lencode[last.val +
1580 (BITS(last.bits + last.op) >> last.bits)];
1581 if ((unsigned)(last.bits + this.bits) <= bits) break;
1584 DROPBITS(last.bits);
1586 DROPBITS(this.bits);
1587 state->length = (unsigned)this.val;
1588 if ((int)(this.op) == 0) {
1589 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
1590 "inflate: literal '%c'\n" :
1591 "inflate: literal 0x%02x\n", this.val));
1596 Tracevv((stderr, "inflate: end of block\n"));
1601 strm->msg = (char *)"invalid literal/length code";
1605 state->extra = (unsigned)(this.op) & 15;
1606 state->mode = LENEXT;
1609 NEEDBITS(state->extra);
1610 state->length += BITS(state->extra);
1611 DROPBITS(state->extra);
1613 Tracevv((stderr, "inflate: length %u\n", state->length));
1617 this = state->distcode[BITS(state->distbits)];
1618 if ((unsigned)(this.bits) <= bits) break;
1621 if ((this.op & 0xf0) == 0) {
1624 this = state->distcode[last.val +
1625 (BITS(last.bits + last.op) >> last.bits)];
1626 if ((unsigned)(last.bits + this.bits) <= bits) break;
1629 DROPBITS(last.bits);
1631 DROPBITS(this.bits);
1633 strm->msg = (char *)"invalid distance code";
1637 state->offset = (unsigned)this.val;
1638 state->extra = (unsigned)(this.op) & 15;
1639 state->mode = DISTEXT;
1642 NEEDBITS(state->extra);
1643 state->offset += BITS(state->extra);
1644 DROPBITS(state->extra);
1646 #ifdef INFLATE_STRICT
1647 if (state->offset > state->dmax) {
1648 strm->msg = (char *)"invalid distance too far back";
1653 if (state->offset > state->whave + out - left) {
1654 strm->msg = (char *)"invalid distance too far back";
1658 Tracevv((stderr, "inflate: distance %u\n", state->offset));
1659 state->mode = MATCH;
1661 if (left == 0) goto inf_leave;
1663 if (state->offset > copy) { /* copy from window */
1664 copy = state->offset - copy;
1665 if (copy > state->write) {
1666 copy -= state->write;
1667 from = state->window + (state->wsize - copy);
1670 from = state->window + (state->write - copy);
1671 if (copy > state->length) copy = state->length;
1673 else { /* copy from output */
1674 from = put - state->offset;
1675 copy = state->length;
1677 if (copy > left) copy = left;
1679 state->length -= copy;
1683 if (state->length == 0) state->mode = LEN;
1686 if (left == 0) goto inf_leave;
1687 *put++ = (unsigned char)(state->length);
1695 strm->total_out += out;
1696 state->total += out;
1698 strm->adler = state->check =
1699 UPDATE(state->check, put - out, out);
1703 state->flags ? hold :
1705 REVERSE(hold)) != state->check) {
1706 strm->msg = (char *)"incorrect data check";
1711 Tracev((stderr, "inflate: check matches trailer\n"));
1714 state->mode = LENGTH;
1716 if (state->wrap && state->flags) {
1718 if (hold != (state->total & 0xffffffffUL)) {
1719 strm->msg = (char *)"incorrect length check";
1724 Tracev((stderr, "inflate: length matches trailer\n"));
1738 return Z_STREAM_ERROR;
1742 Return from inflate(), updating the total counts and the check value.
1743 If there was no progress during the inflate() call, return a buffer
1744 error. Call updatewindow() to create and/or update the window state.
1745 Note: a memory error from inflate() is non-recoverable.
1749 if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
1750 if (updatewindow(strm, out)) {
1754 in -= strm->avail_in;
1755 out -= strm->avail_out;
1756 strm->total_in += in;
1757 strm->total_out += out;
1758 state->total += out;
1759 if (state->wrap && out)
1760 strm->adler = state->check =
1761 UPDATE(state->check, strm->next_out - out, out);
1762 strm->data_type = state->bits + (state->last ? 64 : 0) +
1763 (state->mode == TYPE ? 128 : 0);
1764 if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1768 int ZEXPORT inflateEnd(strm)
1771 struct inflate_state FAR *state;
1772 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
1773 return Z_STREAM_ERROR;
1774 state = (struct inflate_state FAR *)strm->state;
1775 if (state->window != Z_NULL) ZFREE(strm, state->window);
1776 if (state->dist_window != Z_NULL) ZFREE(strm, state->dist_window);
1777 ZFREE(strm, strm->state);
1778 strm->state = Z_NULL;
1779 Tracev((stderr, "inflate: end\n"));
1783 int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
1785 const Bytef *dictionary;
1788 struct inflate_state FAR *state;
1792 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1793 state = (struct inflate_state FAR *)strm->state;
1794 if (state->wrap != 0 && state->mode != DICT)
1795 return Z_STREAM_ERROR;
1797 /* check for correct dictionary id */
1798 if (state->mode == DICT) {
1799 id = adler32(0L, Z_NULL, 0);
1800 id = adler32(id, dictionary, dictLength);
1801 if (id != state->check)
1802 return Z_DATA_ERROR;
1805 /* copy dictionary to window */
1806 if (updatewindow(strm, strm->avail_out)) {
1810 if (dictLength > state->wsize) {
1811 zmemcpy(state->window, dictionary + dictLength - state->wsize,
1813 state->whave = state->wsize;
1816 zmemcpy(state->window + state->wsize - dictLength, dictionary,
1818 state->whave = dictLength;
1820 state->havedict = 1;
1821 Tracev((stderr, "inflate: dictionary set\n"));
1825 int ZEXPORT inflateGetHeader(strm, head)
1829 struct inflate_state FAR *state;
1832 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1833 state = (struct inflate_state FAR *)strm->state;
1834 if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1836 /* save header structure */
1843 Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
1844 or when out of input. When called, *have is the number of pattern bytes
1845 found in order so far, in 0..3. On return *have is updated to the new
1846 state. If on return *have equals four, then the pattern was found and the
1847 return value is how many bytes were read including the last byte of the
1848 pattern. If *have is less than four, then the pattern has not been found
1849 yet and the return value is len. In the latter case, syncsearch() can be
1850 called again with more data and the *have state. *have is initialized to
1851 zero for the first call.
1853 local unsigned syncsearch(have, buf, len)
1855 unsigned char FAR *buf;
1863 while (next < len && got < 4) {
1864 if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
1876 int ZEXPORT inflateSync(strm)
1879 unsigned len; /* number of bytes to look at or looked at */
1880 unsigned long in, out; /* temporary to save total_in and total_out */
1881 unsigned char buf[4]; /* to restore bit buffer to byte string */
1882 struct inflate_state FAR *state;
1884 /* check parameters */
1885 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1886 state = (struct inflate_state FAR *)strm->state;
1887 if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1889 /* if first time, start search in bit buffer */
1890 if (state->mode != SYNC) {
1892 state->hold <<= state->bits & 7;
1893 state->bits -= state->bits & 7;
1895 while (state->bits >= 8) {
1896 buf[len++] = (unsigned char)(state->hold);
1901 syncsearch(&(state->have), buf, len);
1904 /* search available input */
1905 len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1906 strm->avail_in -= len;
1907 strm->next_in += len;
1908 strm->total_in += len;
1910 /* return no joy or set up to restart inflate() on a new block */
1911 if (state->have != 4) return Z_DATA_ERROR;
1912 in = strm->total_in; out = strm->total_out;
1914 strm->total_in = in; strm->total_out = out;
1920 Returns true if inflate is currently at the end of a block generated by
1921 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
1922 implementation to provide an additional safety check. PPP uses
1923 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
1924 block. When decompressing, PPP checks that at the end of input packet,
1925 inflate is waiting for these length bytes.
1927 int ZEXPORT inflateSyncPoint(strm)
1930 struct inflate_state FAR *state;
1932 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1933 state = (struct inflate_state FAR *)strm->state;
1934 return state->mode == STORED && state->bits == 0;
1937 int ZEXPORT inflateCopy(dest, source)
1941 struct inflate_state FAR *state;
1942 struct inflate_state FAR *copy;
1943 unsigned char FAR *window;
1947 if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
1948 source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
1949 return Z_STREAM_ERROR;
1950 state = (struct inflate_state FAR *)source->state;
1952 /* allocate space */
1953 copy = (struct inflate_state FAR *)
1954 ZALLOC(source, 1, sizeof(struct inflate_state));
1955 if (copy == Z_NULL) return Z_MEM_ERROR;
1957 if (state->window != Z_NULL) {
1958 window = (unsigned char FAR *)
1959 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1960 if (window == Z_NULL) {
1961 ZFREE(source, copy);
1967 zmemcpy(dest, source, sizeof(z_stream));
1968 zmemcpy(copy, state, sizeof(struct inflate_state));
1969 if (state->lencode >= state->codes &&
1970 state->lencode <= state->codes + ENOUGH - 1) {
1971 copy->lencode = copy->codes + (state->lencode - state->codes);
1972 copy->distcode = copy->codes + (state->distcode - state->codes);
1974 copy->next = copy->codes + (state->next - state->codes);
1975 if (window != Z_NULL) {
1976 wsize = 1U << state->wbits;
1977 zmemcpy(window, state->window, wsize);
1979 copy->window = window;
1980 dest->state = (struct internal_state FAR *)copy;