1 /* inflate.c -- zlib decompression
2 * Copyright (C) 1995-2003 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 *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;
118 state->lencode = state->distcode = state->next = state->codes;
119 Tracev((stderr, "inflate: reset\n"));
123 int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
129 struct inflate_state FAR *state;
131 if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
132 stream_size != (int)(sizeof(z_stream)))
133 return Z_VERSION_ERROR;
134 if (strm == Z_NULL) return Z_STREAM_ERROR;
135 strm->msg = Z_NULL; /* in case we return an error */
136 if (strm->zalloc == Z_NULL) {
137 strm->zalloc = zcalloc;
138 strm->opaque = (voidpf)0;
140 if (strm->zfree == Z_NULL) strm->zfree = zcfree;
141 state = (struct inflate_state FAR *)
142 ZALLOC(strm, 1, sizeof(struct inflate_state));
143 if (state == Z_NULL) return Z_MEM_ERROR;
144 Tracev((stderr, "inflate: allocated\n"));
145 strm->state = (voidpf)state;
146 if (windowBits < 0) {
148 windowBits = -windowBits;
151 state->wrap = (windowBits >> 4) + 1;
156 if (windowBits < 8 || windowBits > 15) {
158 strm->state = Z_NULL;
159 return Z_STREAM_ERROR;
161 state->wbits = (unsigned)windowBits;
162 state->window = Z_NULL;
163 return inflateReset(strm);
166 int ZEXPORT inflateInit_(strm, version, stream_size)
171 return inflateInit2_(strm, DEF_WBITS, version, stream_size);
175 Return state with length and distance decoding tables and index sizes set to
176 fixed code decoding. Normally this returns fixed tables from inffixed.h.
177 If BUILDFIXED is defined, then instead this routine builds the tables the
178 first time it's called, and returns those tables the first time and
179 thereafter. This reduces the size of the code by about 2K bytes, in
180 exchange for a little execution time. However, BUILDFIXED should not be
181 used for threaded applications, since the rewriting of the tables and virgin
182 may not be thread-safe.
184 local void fixedtables(state)
185 struct inflate_state FAR *state;
188 static int virgin = 1;
189 static code *lenfix, *distfix;
190 static code fixed[544];
192 /* build fixed huffman tables if first call (may not be thread safe) */
197 /* literal/length table */
199 while (sym < 144) state->lens[sym++] = 8;
200 while (sym < 256) state->lens[sym++] = 9;
201 while (sym < 280) state->lens[sym++] = 7;
202 while (sym < 288) state->lens[sym++] = 8;
206 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
210 while (sym < 32) state->lens[sym++] = 5;
213 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
215 /* do this just once */
218 #else /* !BUILDFIXED */
219 # include "inffixed.h"
220 #endif /* BUILDFIXED */
221 state->lencode = lenfix;
223 state->distcode = distfix;
231 Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also
232 defines BUILDFIXED, so the tables are built on the fly. makefixed() writes
233 those tables to stdout, which would be piped to inffixed.h. A small program
234 can simply call makefixed to do this:
236 void makefixed(void);
244 Then that can be linked with zlib built with MAKEFIXED defined and run:
251 struct inflate_state state;
254 puts(" /* inffixed.h -- table for decoding fixed codes");
255 puts(" * Generated automatically by makefixed().");
258 puts(" /* WARNING: this file should *not* be used by applications.");
259 puts(" It is part of the implementation of this library and is");
260 puts(" subject to change. Applications should only use zlib.h.");
264 printf(" static const code lenfix[%u] = {", size);
267 if ((low % 7) == 0) printf("\n ");
268 printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
269 state.lencode[low].val);
270 if (++low == size) break;
275 printf("\n static const code distfix[%u] = {", size);
278 if ((low % 6) == 0) printf("\n ");
279 printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
280 state.distcode[low].val);
281 if (++low == size) break;
286 #endif /* MAKEFIXED */
289 Update the window with the last wsize (normally 32K) bytes written before
290 returning. If window does not exist yet, create it. This is only called
291 when a window is already in use, or when output has been written during this
292 inflate call, but the end of the deflate stream has not been reached yet.
293 It is also called to create a window for dictionary data when a dictionary
296 Providing output buffers larger than 32K to inflate() should provide a speed
297 advantage, since only the last 32K of output is copied to the sliding window
298 upon return from inflate(), and since all distances after the first 32K of
299 output will fall in the output data, making match copies simpler and faster.
300 The advantage may be dependent on the size of the processor's data caches.
302 local int updatewindow(strm, out)
306 struct inflate_state FAR *state;
309 state = (struct inflate_state FAR *)strm->state;
311 /* if it hasn't been done already, allocate space for the window */
312 if (state->window == Z_NULL) {
313 state->window = (unsigned char FAR *)
314 ZALLOC(strm, 1U << state->wbits,
315 sizeof(unsigned char));
316 if (state->window == Z_NULL) return 1;
319 /* if window not in use yet, initialize */
320 if (state->wsize == 0) {
321 state->wsize = 1U << state->wbits;
325 /* copy state->wsize or less output bytes into the circular window */
326 copy = out - strm->avail_out;
327 if (copy >= state->wsize) {
328 zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
332 dist = state->wsize - state->write;
333 if (dist > copy) dist = copy;
334 zmemcpy(state->window + state->write, strm->next_out - copy, dist);
337 zmemcpy(state->window, strm->next_out - copy, copy);
341 state->write += dist;
342 if (state->write == state->wsize) state->write = 0;
348 /* Macros for inflate(): */
350 /* check function to use adler32() for zlib or crc32() for gzip */
352 # define UPDATE(check, buf, len) \
353 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
355 # define UPDATE(check, buf, len) adler32(check, buf, len)
358 /* check macros for header crc */
360 # define CRC2(check, word) \
362 hbuf[0] = (unsigned char)(word); \
363 hbuf[1] = (unsigned char)((word) >> 8); \
364 check = crc32(check, hbuf, 2); \
367 # define CRC4(check, word) \
369 hbuf[0] = (unsigned char)(word); \
370 hbuf[1] = (unsigned char)((word) >> 8); \
371 hbuf[2] = (unsigned char)((word) >> 16); \
372 hbuf[3] = (unsigned char)((word) >> 24); \
373 check = crc32(check, hbuf, 4); \
377 /* Load registers with state in inflate() for speed */
380 put = strm->next_out; \
381 left = strm->avail_out; \
382 next = strm->next_in; \
383 have = strm->avail_in; \
384 hold = state->hold; \
385 bits = state->bits; \
388 /* Restore state from registers in inflate() */
391 strm->next_out = put; \
392 strm->avail_out = left; \
393 strm->next_in = next; \
394 strm->avail_in = have; \
395 state->hold = hold; \
396 state->bits = bits; \
399 /* Clear the input bit accumulator */
406 /* Get a byte of input into the bit accumulator, or return from inflate()
407 if there is no input available. */
410 if (have == 0) goto inf_leave; \
412 hold += (unsigned long)(*next++) << bits; \
416 /* Assure that there are at least n bits in the bit accumulator. If there is
417 not enough available input to do that, then return from inflate(). */
418 #define NEEDBITS(n) \
420 while (bits < (unsigned)(n)) \
424 /* Return the low n bits of the bit accumulator (n < 16) */
426 ((unsigned)hold & ((1U << (n)) - 1))
428 /* Remove n bits from the bit accumulator */
429 #define DROPBITS(n) \
432 bits -= (unsigned)(n); \
435 /* Remove zero to seven bits as needed to go to a byte boundary */
442 /* Reverse the bytes in a 32-bit value */
444 ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
445 (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
448 inflate() uses a state machine to process as much input data and generate as
449 much output data as possible before returning. The state machine is
450 structured roughly as follows:
452 for (;;) switch (state) {
455 if (not enough input data or output space to make progress)
457 ... make progress ...
463 so when inflate() is called again, the same case is attempted again, and
464 if the appropriate resources are provided, the machine proceeds to the
465 next state. The NEEDBITS() macro is usually the way the state evaluates
466 whether it can proceed or should return. NEEDBITS() does the return if
467 the requested bits are not available. The typical use of the BITS macros
471 ... do something with BITS(n) ...
474 where NEEDBITS(n) either returns from inflate() if there isn't enough
475 input left to load n bits into the accumulator, or it continues. BITS(n)
476 gives the low n bits in the accumulator. When done, DROPBITS(n) drops
477 the low n bits off the accumulator. INITBITS() clears the accumulator
478 and sets the number of available bits to zero. BYTEBITS() discards just
479 enough bits to put the accumulator on a byte boundary. After BYTEBITS()
480 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
482 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
483 if there is no input available. The decoding of variable length codes uses
484 PULLBYTE() directly in order to pull just enough bytes to decode the next
487 Some states loop until they get enough input, making sure that enough
488 state information is maintained to continue the loop where it left off
489 if NEEDBITS() returns in the loop. For example, want, need, and keep
490 would all have to actually be part of the saved state in case NEEDBITS()
494 while (want < need) {
496 keep[want++] = BITS(n);
502 As shown above, if the next state is also the next case, then the break
505 A state may also return if there is not enough output space available to
506 complete that state. Those states are copying stored data, writing a
507 literal byte, and copying a matching string.
509 When returning, a "goto inf_leave" is used to update the total counters,
510 update the check value, and determine whether any progress has been made
511 during that inflate() call in order to return the proper return code.
512 Progress is defined as a change in either strm->avail_in or strm->avail_out.
513 When there is a window, goto inf_leave will update the window with the last
514 output written. If a goto inf_leave occurs in the middle of decompression
515 and there is no window currently, goto inf_leave will create one and copy
516 output to the window for the next call of inflate().
518 In this implementation, the flush parameter of inflate() only affects the
519 return code (per zlib.h). inflate() always writes as much as possible to
520 strm->next_out, given the space available and the provided input--the effect
521 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
522 the allocation of and copying into a sliding window until necessary, which
523 provides the effect documented in zlib.h for Z_FINISH when the entire input
524 stream available. So the only thing the flush parameter actually does is:
525 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
526 will return Z_BUF_ERROR if it has not reached the end of the stream.
529 int ZEXPORT inflate(strm, flush)
533 struct inflate_state FAR *state;
534 unsigned char *next, *put; /* next input and output */
535 unsigned have, left; /* available input and output */
536 unsigned long hold; /* bit buffer */
537 unsigned bits; /* bits in bit buffer */
538 unsigned in, out; /* save starting available input and output */
539 unsigned copy; /* number of stored or match bytes to copy */
540 unsigned char *from; /* where to copy match bytes from */
541 code this; /* current decoding table entry */
542 code last; /* parent table entry */
543 unsigned len; /* length to copy for repeats, bits to drop */
544 int ret; /* return code */
546 unsigned char hbuf[4]; /* buffer for gzip header crc calculation */
548 static const unsigned short order[19] = /* permutation of code lengths */
549 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
551 if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
552 (strm->next_in == Z_NULL && strm->avail_in != 0))
553 return Z_STREAM_ERROR;
555 state = (struct inflate_state FAR *)strm->state;
561 switch (state->mode) {
563 if (state->wrap == 0) {
569 if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
570 state->check = crc32(0L, Z_NULL, 0);
571 CRC2(state->check, hold);
576 state->flags = 0; /* expect zlib header */
577 if (!(state->wrap & 1) || /* check if zlib header allowed */
581 ((BITS(8) << 8) + (hold >> 8)) % 31) {
582 strm->msg = (char *)"incorrect header check";
586 if (BITS(4) != Z_DEFLATED) {
587 strm->msg = (char *)"unknown compression method";
592 if (BITS(4) + 8 > state->wbits) {
593 strm->msg = (char *)"invalid window size";
597 Tracev((stderr, "inflate: zlib header ok\n"));
598 strm->adler = state->check = adler32(0L, Z_NULL, 0);
599 state->mode = hold & 0x200 ? DICTID : TYPE;
605 state->flags = (int)(hold);
606 if ((state->flags & 0xff) != Z_DEFLATED) {
607 strm->msg = (char *)"unknown compression method";
611 if (state->flags & 0xe000) {
612 strm->msg = (char *)"unknown header flags set";
616 if (state->flags & 0x0200) CRC2(state->check, hold);
621 if (state->flags & 0x0200) CRC4(state->check, hold);
626 if (state->flags & 0x0200) CRC2(state->check, hold);
630 if (state->flags & 0x0400) {
632 state->length = (unsigned)(hold);
633 if (state->flags & 0x0200) CRC2(state->check, hold);
638 if (state->flags & 0x0400) {
639 copy = state->length;
640 if (copy > have) copy = have;
642 if (state->flags & 0x0200)
643 state->check = crc32(state->check, next, copy);
646 state->length -= copy;
648 if (state->length) goto inf_leave;
652 if (state->flags & 0x0800) {
653 if (have == 0) goto inf_leave;
656 len = (unsigned)(next[copy++]);
657 } while (len && copy < have);
658 if (state->flags & 0x02000)
659 state->check = crc32(state->check, next, copy);
662 if (len) goto inf_leave;
664 state->mode = COMMENT;
666 if (state->flags & 0x1000) {
667 if (have == 0) goto inf_leave;
670 len = (unsigned)(next[copy++]);
671 } while (len && copy < have);
672 if (state->flags & 0x02000)
673 state->check = crc32(state->check, next, copy);
676 if (len) goto inf_leave;
680 if (state->flags & 0x0200) {
682 if (hold != (state->check & 0xffff)) {
683 strm->msg = (char *)"header crc mismatch";
689 strm->adler = state->check = crc32(0L, Z_NULL, 0);
695 strm->adler = state->check = REVERSE(hold);
699 if (state->havedict == 0) {
703 strm->adler = state->check = adler32(0L, Z_NULL, 0);
712 state->last = BITS(1);
715 case 0: /* stored block */
716 Tracev((stderr, "inflate: stored block%s\n",
717 state->last ? " (last)" : ""));
718 state->mode = STORED;
720 case 1: /* fixed block */
722 Tracev((stderr, "inflate: fixed codes block%s\n",
723 state->last ? " (last)" : ""));
724 state->mode = LEN; /* decode codes */
726 case 2: /* dynamic block */
727 Tracev((stderr, "inflate: dynamic codes block%s\n",
728 state->last ? " (last)" : ""));
732 strm->msg = (char *)"invalid block type";
738 BYTEBITS(); /* go to byte boundary */
740 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
741 strm->msg = (char *)"invalid stored block lengths";
745 state->length = (unsigned)hold & 0xffff;
746 Tracev((stderr, "inflate: stored length %u\n",
751 copy = state->length;
753 if (copy > have) copy = have;
754 if (copy > left) copy = left;
755 if (copy == 0) goto inf_leave;
756 zmemcpy(put, next, copy);
761 state->length -= copy;
764 Tracev((stderr, "inflate: stored end\n"));
769 state->nlen = BITS(5) + 257;
771 state->ndist = BITS(5) + 1;
773 state->ncode = BITS(4) + 4;
775 #ifndef PKZIP_BUG_WORKAROUND
776 if (state->nlen > 286 || state->ndist > 30) {
777 strm->msg = (char *)"too many length or distance symbols";
782 Tracev((stderr, "inflate: table sizes ok\n"));
784 state->mode = LENLENS;
786 while (state->have < state->ncode) {
788 state->lens[order[state->have++]] = (unsigned short)BITS(3);
791 while (state->have < 19)
792 state->lens[order[state->have++]] = 0;
793 state->next = state->codes;
794 state->lencode = (code const FAR *)(state->next);
796 ret = inflate_table(CODES, state->lens, 19, &(state->next),
797 &(state->lenbits), state->work);
799 strm->msg = (char *)"invalid code lengths set";
803 Tracev((stderr, "inflate: code lengths ok\n"));
805 state->mode = CODELENS;
807 while (state->have < state->nlen + state->ndist) {
809 this = state->lencode[BITS(state->lenbits)];
810 if ((unsigned)(this.bits) <= bits) break;
816 state->lens[state->have++] = this.val;
819 if (this.val == 16) {
820 NEEDBITS(this.bits + 2);
822 if (state->have == 0) {
823 strm->msg = (char *)"invalid bit length repeat";
827 len = state->lens[state->have - 1];
831 else if (this.val == 17) {
832 NEEDBITS(this.bits + 3);
839 NEEDBITS(this.bits + 7);
845 if (state->have + copy > state->nlen + state->ndist) {
846 strm->msg = (char *)"invalid bit length repeat";
851 state->lens[state->have++] = (unsigned short)len;
855 /* build code tables */
856 state->next = state->codes;
857 state->lencode = (code const FAR *)(state->next);
859 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
860 &(state->lenbits), state->work);
862 strm->msg = (char *)"invalid literal/lengths set";
866 state->distcode = (code const FAR *)(state->next);
868 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
869 &(state->next), &(state->distbits), state->work);
871 strm->msg = (char *)"invalid distances set";
875 Tracev((stderr, "inflate: codes ok\n"));
878 if (have >= 6 && left >= 258) {
880 inflate_fast(strm, out);
885 this = state->lencode[BITS(state->lenbits)];
886 if ((unsigned)(this.bits) <= bits) break;
889 if (this.op && (this.op & 0xf0) == 0) {
892 this = state->lencode[last.val +
893 (BITS(last.bits + last.op) >> last.bits)];
894 if ((unsigned)(last.bits + this.bits) <= bits) break;
900 state->length = (unsigned)this.val;
901 if ((int)(this.op) == 0) {
902 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
903 "inflate: literal '%c'\n" :
904 "inflate: literal 0x%02x\n", this.val));
909 Tracevv((stderr, "inflate: end of block\n"));
914 strm->msg = (char *)"invalid literal/length code";
918 state->extra = (unsigned)(this.op) & 15;
919 state->mode = LENEXT;
922 NEEDBITS(state->extra);
923 state->length += BITS(state->extra);
924 DROPBITS(state->extra);
926 Tracevv((stderr, "inflate: length %u\n", state->length));
930 this = state->distcode[BITS(state->distbits)];
931 if ((unsigned)(this.bits) <= bits) break;
934 if ((this.op & 0xf0) == 0) {
937 this = state->distcode[last.val +
938 (BITS(last.bits + last.op) >> last.bits)];
939 if ((unsigned)(last.bits + this.bits) <= bits) break;
946 strm->msg = (char *)"invalid distance code";
950 state->offset = (unsigned)this.val;
951 state->extra = (unsigned)(this.op) & 15;
952 state->mode = DISTEXT;
955 NEEDBITS(state->extra);
956 state->offset += BITS(state->extra);
957 DROPBITS(state->extra);
959 if (state->offset > (state->wsize ? state->wsize :
961 strm->msg = (char *)"invalid distance too far back";
965 Tracevv((stderr, "inflate: distance %u\n", state->offset));
968 if (left == 0) goto inf_leave;
970 if (state->offset > copy) { /* copy from window */
971 copy = state->offset - copy;
972 if (copy > state->write) {
973 copy -= state->write;
974 from = state->window + (state->wsize - copy);
977 from = state->window + (state->write - copy);
978 if (copy > state->length) copy = state->length;
980 else { /* copy from output */
981 from = put - state->offset;
982 copy = state->length;
984 if (copy > left) copy = left;
986 state->length -= copy;
990 if (state->length == 0) state->mode = LEN;
993 if (left == 0) goto inf_leave;
994 *put++ = (unsigned char)(state->length);
1002 strm->total_out += out;
1003 state->total += out;
1005 strm->adler = state->check =
1006 UPDATE(state->check, put - out, out);
1010 state->flags ? hold :
1012 REVERSE(hold)) != state->check) {
1013 strm->msg = (char *)"incorrect data check";
1018 Tracev((stderr, "inflate: check matches trailer\n"));
1021 state->mode = LENGTH;
1023 if (state->wrap && state->flags) {
1025 if (hold != (state->total & 0xffffffffUL)) {
1026 strm->msg = (char *)"incorrect length check";
1031 Tracev((stderr, "inflate: length matches trailer\n"));
1045 return Z_STREAM_ERROR;
1049 Return from inflate(), updating the total counts and the check value.
1050 If there was no progress during the inflate() call, return a buffer
1051 error. Call updatewindow() to create and/or update the window state.
1052 Note: a memory error from inflate() is non-recoverable.
1056 if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
1057 if (updatewindow(strm, out)) {
1061 in -= strm->avail_in;
1062 out -= strm->avail_out;
1063 strm->total_in += in;
1064 strm->total_out += out;
1065 state->total += out;
1066 if (state->wrap && out)
1067 strm->adler = state->check =
1068 UPDATE(state->check, strm->next_out - out, out);
1069 if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1074 int ZEXPORT inflateEnd(strm)
1077 struct inflate_state FAR *state;
1078 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == Z_NULL)
1079 return Z_STREAM_ERROR;
1080 state = (struct inflate_state FAR *)strm->state;
1081 if (state->window != Z_NULL) ZFREE(strm, state->window);
1082 ZFREE(strm, strm->state);
1083 strm->state = Z_NULL;
1084 Tracev((stderr, "inflate: end\n"));
1088 int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
1090 const Bytef *dictionary;
1093 struct inflate_state FAR *state;
1097 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1098 state = (struct inflate_state FAR *)strm->state;
1099 if (state->mode != DICT) return Z_STREAM_ERROR;
1101 /* check for correct dictionary id */
1102 id = adler32(0L, Z_NULL, 0);
1103 id = adler32(id, dictionary, dictLength);
1104 if (id != state->check) return Z_DATA_ERROR;
1106 /* copy dictionary to window */
1107 if (updatewindow(strm, strm->avail_out)) {
1111 if (dictLength > state->wsize)
1112 zmemcpy(state->window, dictionary + dictLength - state->wsize,
1115 zmemcpy(state->window + state->wsize - dictLength, dictionary,
1117 state->havedict = 1;
1118 Tracev((stderr, "inflate: dictionary set\n"));
1123 Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
1124 or when out of input. When called, *have is the number of pattern bytes
1125 found in order so far, in 0..3. On return *have is updated to the new
1126 state. If on return *have equals four, then the pattern was found and the
1127 return value is how many bytes were read including the last byte of the
1128 pattern. If *have is less than four, then the pattern has not been found
1129 yet and the return value is len. In the latter case, syncsearch() can be
1130 called again with more data and the *have state. *have is initialized to
1131 zero for the first call.
1133 local unsigned syncsearch(have, buf, len)
1135 unsigned char FAR *buf;
1143 while (next < len && got < 4) {
1144 if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
1156 int ZEXPORT inflateSync(strm)
1159 unsigned len; /* number of bytes to look at or looked at */
1160 unsigned long in, out; /* temporary to save total_in and total_out */
1161 unsigned char buf[4]; /* to restore bit buffer to byte string */
1162 struct inflate_state FAR *state;
1164 /* check parameters */
1165 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1166 state = (struct inflate_state FAR *)strm->state;
1167 if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1169 /* if first time, start search in bit buffer */
1170 if (state->mode != SYNC) {
1172 state->hold <<= state->bits & 7;
1173 state->bits -= state->bits & 7;
1175 while (state->bits >= 8) {
1176 buf[len++] = (unsigned char)(state->hold);
1181 syncsearch(&(state->have), buf, len);
1184 /* search available input */
1185 len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1186 strm->avail_in -= len;
1187 strm->next_in += len;
1188 strm->total_in += len;
1190 /* return no joy or set up to restart inflate() on a new block */
1191 if (state->have != 4) return Z_DATA_ERROR;
1192 in = strm->total_in; out = strm->total_out;
1194 strm->total_in = in; strm->total_out = out;
1200 Returns true if inflate is currently at the end of a block generated by
1201 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
1202 implementation to provide an additional safety check. PPP uses
1203 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
1204 block. When decompressing, PPP checks that at the end of input packet,
1205 inflate is waiting for these length bytes.
1207 int ZEXPORT inflateSyncPoint(strm)
1210 struct inflate_state FAR *state;
1212 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1213 state = (struct inflate_state FAR *)strm->state;
1214 return state->mode == STORED && state->bits == 0;
1217 int ZEXPORT inflateCopy(dest, source)
1221 struct inflate_state FAR *state;
1222 struct inflate_state FAR *copy;
1223 unsigned char FAR *window;
1226 if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
1227 source->zalloc == Z_NULL || source->zfree == Z_NULL)
1228 return Z_STREAM_ERROR;
1229 state = (struct inflate_state FAR *)source->state;
1231 /* allocate space */
1232 copy = (struct inflate_state FAR *)
1233 ZALLOC(source, 1, sizeof(struct inflate_state));
1234 if (copy == Z_NULL) return Z_MEM_ERROR;
1236 if (state->window != Z_NULL) {
1237 window = (unsigned char FAR *)
1238 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1239 if (window == Z_NULL) {
1240 ZFREE(source, copy);
1248 copy->lencode = copy->codes + (state->lencode - state->codes);
1249 copy->distcode = copy->codes + (state->distcode - state->codes);
1250 copy->next = copy->codes + (state->next - state->codes);
1251 if (window != Z_NULL)
1252 zmemcpy(window, state->window, 1U << state->wbits);
1253 copy->window = window;
1254 dest->state = (voidpf)copy;