1 /* inflate.c -- zlib decompression
2 * Copyright (C) 1995-2010 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 wnext == 0 case for speed in inflate_fast()
49 * - Make op and len in inflate_fast() unsigned for consistency
50 * - Add FAR to lcode and dcode declarations in inflate_fast()
51 * - Simplified bad distance check in inflate_fast()
52 * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
53 * source file infback.c to provide a call-back interface to inflate for
54 * programs like gzip and unzip -- uses window as output buffer to avoid
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 inflateResetKeep(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->head = Z_NULL;
120 state->lencode = state->distcode = state->next = state->codes;
123 Tracev((stderr, "inflate: reset\n"));
127 int ZEXPORT inflateReset(strm)
130 struct inflate_state FAR *state;
132 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
133 state = (struct inflate_state FAR *)strm->state;
137 return inflateResetKeep(strm);
140 int ZEXPORT inflateReset2(strm, windowBits)
145 struct inflate_state FAR *state;
148 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
149 state = (struct inflate_state FAR *)strm->state;
151 /* extract wrap request from windowBits parameter */
152 if (windowBits < 0) {
154 windowBits = -windowBits;
157 wrap = (windowBits >> 4) + 1;
164 /* set number of window bits, free window if different */
165 if (windowBits && (windowBits < 8 || windowBits > 15))
166 return Z_STREAM_ERROR;
167 if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
168 ZFREE(strm, state->window);
169 state->window = Z_NULL;
172 /* update state and reset the rest of it */
174 state->wbits = (unsigned)windowBits;
175 return inflateReset(strm);
178 int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
185 struct inflate_state FAR *state;
187 if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
188 stream_size != (int)(sizeof(z_stream)))
189 return Z_VERSION_ERROR;
190 if (strm == Z_NULL) return Z_STREAM_ERROR;
191 strm->msg = Z_NULL; /* in case we return an error */
192 if (strm->zalloc == (alloc_func)0) {
194 return Z_STREAM_ERROR;
196 strm->zalloc = zcalloc;
197 strm->opaque = (voidpf)0;
200 if (strm->zfree == (free_func)0)
202 return Z_STREAM_ERROR;
204 strm->zfree = zcfree;
206 state = (struct inflate_state FAR *)
207 ZALLOC(strm, 1, sizeof(struct inflate_state));
208 if (state == Z_NULL) return Z_MEM_ERROR;
209 Tracev((stderr, "inflate: allocated\n"));
210 strm->state = (struct internal_state FAR *)state;
211 state->window = Z_NULL;
212 ret = inflateReset2(strm, windowBits);
215 strm->state = Z_NULL;
220 int ZEXPORT inflateInit_(strm, version, stream_size)
225 return inflateInit2_(strm, DEF_WBITS, version, stream_size);
228 int ZEXPORT inflatePrime(strm, bits, value)
233 struct inflate_state FAR *state;
235 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
236 state = (struct inflate_state FAR *)strm->state;
242 if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
243 value &= (1L << bits) - 1;
244 state->hold += value << state->bits;
250 Return state with length and distance decoding tables and index sizes set to
251 fixed code decoding. Normally this returns fixed tables from inffixed.h.
252 If BUILDFIXED is defined, then instead this routine builds the tables the
253 first time it's called, and returns those tables the first time and
254 thereafter. This reduces the size of the code by about 2K bytes, in
255 exchange for a little execution time. However, BUILDFIXED should not be
256 used for threaded applications, since the rewriting of the tables and virgin
257 may not be thread-safe.
259 local void fixedtables(state)
260 struct inflate_state FAR *state;
263 static int virgin = 1;
264 static code *lenfix, *distfix;
265 static code fixed[544];
267 /* build fixed huffman tables if first call (may not be thread safe) */
272 /* literal/length table */
274 while (sym < 144) state->lens[sym++] = 8;
275 while (sym < 256) state->lens[sym++] = 9;
276 while (sym < 280) state->lens[sym++] = 7;
277 while (sym < 288) state->lens[sym++] = 8;
281 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
285 while (sym < 32) state->lens[sym++] = 5;
288 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
290 /* do this just once */
293 #else /* !BUILDFIXED */
294 # include "inffixed.h"
295 #endif /* BUILDFIXED */
296 state->lencode = lenfix;
298 state->distcode = distfix;
306 Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also
307 defines BUILDFIXED, so the tables are built on the fly. makefixed() writes
308 those tables to stdout, which would be piped to inffixed.h. A small program
309 can simply call makefixed to do this:
311 void makefixed(void);
319 Then that can be linked with zlib built with MAKEFIXED defined and run:
326 struct inflate_state state;
329 puts(" /* inffixed.h -- table for decoding fixed codes");
330 puts(" * Generated automatically by makefixed().");
333 puts(" /* WARNING: this file should *not* be used by applications.");
334 puts(" It is part of the implementation of this library and is");
335 puts(" subject to change. Applications should only use zlib.h.");
339 printf(" static const code lenfix[%u] = {", size);
342 if ((low % 7) == 0) printf("\n ");
343 printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op,
344 state.lencode[low].bits, state.lencode[low].val);
345 if (++low == size) break;
350 printf("\n static const code distfix[%u] = {", size);
353 if ((low % 6) == 0) printf("\n ");
354 printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
355 state.distcode[low].val);
356 if (++low == size) break;
361 #endif /* MAKEFIXED */
364 Update the window with the last wsize (normally 32K) bytes written before
365 returning. If window does not exist yet, create it. This is only called
366 when a window is already in use, or when output has been written during this
367 inflate call, but the end of the deflate stream has not been reached yet.
368 It is also called to create a window for dictionary data when a dictionary
371 Providing output buffers larger than 32K to inflate() should provide a speed
372 advantage, since only the last 32K of output is copied to the sliding window
373 upon return from inflate(), and since all distances after the first 32K of
374 output will fall in the output data, making match copies simpler and faster.
375 The advantage may be dependent on the size of the processor's data caches.
377 local int updatewindow(strm, out)
381 struct inflate_state FAR *state;
384 state = (struct inflate_state FAR *)strm->state;
386 /* if it hasn't been done already, allocate space for the window */
387 if (state->window == Z_NULL) {
388 state->window = (unsigned char FAR *)
389 ZALLOC(strm, 1U << state->wbits,
390 sizeof(unsigned char));
391 if (state->window == Z_NULL) return 1;
394 /* if window not in use yet, initialize */
395 if (state->wsize == 0) {
396 state->wsize = 1U << state->wbits;
401 /* copy state->wsize or less output bytes into the circular window */
402 copy = out - strm->avail_out;
403 if (copy >= state->wsize) {
404 zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
406 state->whave = state->wsize;
409 dist = state->wsize - state->wnext;
410 if (dist > copy) dist = copy;
411 zmemcpy(state->window + state->wnext, strm->next_out - copy, dist);
414 zmemcpy(state->window, strm->next_out - copy, copy);
416 state->whave = state->wsize;
419 state->wnext += dist;
420 if (state->wnext == state->wsize) state->wnext = 0;
421 if (state->whave < state->wsize) state->whave += dist;
427 /* Macros for inflate(): */
429 /* check function to use adler32() for zlib or crc32() for gzip */
431 # define UPDATE(check, buf, len) \
432 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
434 # define UPDATE(check, buf, len) adler32(check, buf, len)
437 /* check macros for header crc */
439 # define CRC2(check, word) \
441 hbuf[0] = (unsigned char)(word); \
442 hbuf[1] = (unsigned char)((word) >> 8); \
443 check = crc32(check, hbuf, 2); \
446 # define CRC4(check, word) \
448 hbuf[0] = (unsigned char)(word); \
449 hbuf[1] = (unsigned char)((word) >> 8); \
450 hbuf[2] = (unsigned char)((word) >> 16); \
451 hbuf[3] = (unsigned char)((word) >> 24); \
452 check = crc32(check, hbuf, 4); \
456 /* Load registers with state in inflate() for speed */
459 put = strm->next_out; \
460 left = strm->avail_out; \
461 next = strm->next_in; \
462 have = strm->avail_in; \
463 hold = state->hold; \
464 bits = state->bits; \
467 /* Restore state from registers in inflate() */
470 strm->next_out = put; \
471 strm->avail_out = left; \
472 strm->next_in = next; \
473 strm->avail_in = have; \
474 state->hold = hold; \
475 state->bits = bits; \
478 /* Clear the input bit accumulator */
485 /* Get a byte of input into the bit accumulator, or return from inflate()
486 if there is no input available. */
489 if (have == 0) goto inf_leave; \
491 hold += (unsigned long)(*next++) << bits; \
495 /* Assure that there are at least n bits in the bit accumulator. If there is
496 not enough available input to do that, then return from inflate(). */
497 #define NEEDBITS(n) \
499 while (bits < (unsigned)(n)) \
503 /* Return the low n bits of the bit accumulator (n < 16) */
505 ((unsigned)hold & ((1U << (n)) - 1))
507 /* Remove n bits from the bit accumulator */
508 #define DROPBITS(n) \
511 bits -= (unsigned)(n); \
514 /* Remove zero to seven bits as needed to go to a byte boundary */
521 /* Reverse the bytes in a 32-bit value */
523 ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
524 (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
527 inflate() uses a state machine to process as much input data and generate as
528 much output data as possible before returning. The state machine is
529 structured roughly as follows:
531 for (;;) switch (state) {
534 if (not enough input data or output space to make progress)
536 ... make progress ...
542 so when inflate() is called again, the same case is attempted again, and
543 if the appropriate resources are provided, the machine proceeds to the
544 next state. The NEEDBITS() macro is usually the way the state evaluates
545 whether it can proceed or should return. NEEDBITS() does the return if
546 the requested bits are not available. The typical use of the BITS macros
550 ... do something with BITS(n) ...
553 where NEEDBITS(n) either returns from inflate() if there isn't enough
554 input left to load n bits into the accumulator, or it continues. BITS(n)
555 gives the low n bits in the accumulator. When done, DROPBITS(n) drops
556 the low n bits off the accumulator. INITBITS() clears the accumulator
557 and sets the number of available bits to zero. BYTEBITS() discards just
558 enough bits to put the accumulator on a byte boundary. After BYTEBITS()
559 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
561 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
562 if there is no input available. The decoding of variable length codes uses
563 PULLBYTE() directly in order to pull just enough bytes to decode the next
566 Some states loop until they get enough input, making sure that enough
567 state information is maintained to continue the loop where it left off
568 if NEEDBITS() returns in the loop. For example, want, need, and keep
569 would all have to actually be part of the saved state in case NEEDBITS()
573 while (want < need) {
575 keep[want++] = BITS(n);
581 As shown above, if the next state is also the next case, then the break
584 A state may also return if there is not enough output space available to
585 complete that state. Those states are copying stored data, writing a
586 literal byte, and copying a matching string.
588 When returning, a "goto inf_leave" is used to update the total counters,
589 update the check value, and determine whether any progress has been made
590 during that inflate() call in order to return the proper return code.
591 Progress is defined as a change in either strm->avail_in or strm->avail_out.
592 When there is a window, goto inf_leave will update the window with the last
593 output written. If a goto inf_leave occurs in the middle of decompression
594 and there is no window currently, goto inf_leave will create one and copy
595 output to the window for the next call of inflate().
597 In this implementation, the flush parameter of inflate() only affects the
598 return code (per zlib.h). inflate() always writes as much as possible to
599 strm->next_out, given the space available and the provided input--the effect
600 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
601 the allocation of and copying into a sliding window until necessary, which
602 provides the effect documented in zlib.h for Z_FINISH when the entire input
603 stream available. So the only thing the flush parameter actually does is:
604 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
605 will return Z_BUF_ERROR if it has not reached the end of the stream.
608 int ZEXPORT inflate(strm, flush)
612 struct inflate_state FAR *state;
613 unsigned char FAR *next; /* next input */
614 unsigned char FAR *put; /* next output */
615 unsigned have, left; /* available input and output */
616 unsigned long hold; /* bit buffer */
617 unsigned bits; /* bits in bit buffer */
618 unsigned in, out; /* save starting available input and output */
619 unsigned copy; /* number of stored or match bytes to copy */
620 unsigned char FAR *from; /* where to copy match bytes from */
621 code here; /* current decoding table entry */
622 code last; /* parent table entry */
623 unsigned len; /* length to copy for repeats, bits to drop */
624 int ret; /* return code */
626 unsigned char hbuf[4]; /* buffer for gzip header crc calculation */
628 static const unsigned short order[19] = /* permutation of code lengths */
629 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
631 if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
632 (strm->next_in == Z_NULL && strm->avail_in != 0))
633 return Z_STREAM_ERROR;
635 state = (struct inflate_state FAR *)strm->state;
636 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
642 switch (state->mode) {
644 if (state->wrap == 0) {
645 state->mode = TYPEDO;
650 if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
651 state->check = crc32(0L, Z_NULL, 0);
652 CRC2(state->check, hold);
657 state->flags = 0; /* expect zlib header */
658 if (state->head != Z_NULL)
659 state->head->done = -1;
660 if (!(state->wrap & 1) || /* check if zlib header allowed */
664 ((BITS(8) << 8) + (hold >> 8)) % 31) {
665 strm->msg = (char *)"incorrect header check";
669 if (BITS(4) != Z_DEFLATED) {
670 strm->msg = (char *)"unknown compression method";
676 if (state->wbits == 0)
678 else if (len > state->wbits) {
679 strm->msg = (char *)"invalid window size";
683 state->dmax = 1U << len;
684 Tracev((stderr, "inflate: zlib header ok\n"));
685 strm->adler = state->check = adler32(0L, Z_NULL, 0);
686 state->mode = hold & 0x200 ? DICTID : TYPE;
692 state->flags = (int)(hold);
693 if ((state->flags & 0xff) != Z_DEFLATED) {
694 strm->msg = (char *)"unknown compression method";
698 if (state->flags & 0xe000) {
699 strm->msg = (char *)"unknown header flags set";
703 if (state->head != Z_NULL)
704 state->head->text = (int)((hold >> 8) & 1);
705 if (state->flags & 0x0200) CRC2(state->check, hold);
710 if (state->head != Z_NULL)
711 state->head->time = hold;
712 if (state->flags & 0x0200) CRC4(state->check, hold);
717 if (state->head != Z_NULL) {
718 state->head->xflags = (int)(hold & 0xff);
719 state->head->os = (int)(hold >> 8);
721 if (state->flags & 0x0200) CRC2(state->check, hold);
725 if (state->flags & 0x0400) {
727 state->length = (unsigned)(hold);
728 if (state->head != Z_NULL)
729 state->head->extra_len = (unsigned)hold;
730 if (state->flags & 0x0200) CRC2(state->check, hold);
733 else if (state->head != Z_NULL)
734 state->head->extra = Z_NULL;
737 if (state->flags & 0x0400) {
738 copy = state->length;
739 if (copy > have) copy = have;
741 if (state->head != Z_NULL &&
742 state->head->extra != Z_NULL) {
743 len = state->head->extra_len - state->length;
744 zmemcpy(state->head->extra + len, next,
745 len + copy > state->head->extra_max ?
746 state->head->extra_max - len : copy);
748 if (state->flags & 0x0200)
749 state->check = crc32(state->check, next, copy);
752 state->length -= copy;
754 if (state->length) goto inf_leave;
759 if (state->flags & 0x0800) {
760 if (have == 0) goto inf_leave;
763 len = (unsigned)(next[copy++]);
764 if (state->head != Z_NULL &&
765 state->head->name != Z_NULL &&
766 state->length < state->head->name_max)
767 state->head->name[state->length++] = len;
768 } while (len && copy < have);
769 if (state->flags & 0x0200)
770 state->check = crc32(state->check, next, copy);
773 if (len) goto inf_leave;
775 else if (state->head != Z_NULL)
776 state->head->name = Z_NULL;
778 state->mode = COMMENT;
780 if (state->flags & 0x1000) {
781 if (have == 0) goto inf_leave;
784 len = (unsigned)(next[copy++]);
785 if (state->head != Z_NULL &&
786 state->head->comment != Z_NULL &&
787 state->length < state->head->comm_max)
788 state->head->comment[state->length++] = len;
789 } while (len && copy < have);
790 if (state->flags & 0x0200)
791 state->check = crc32(state->check, next, copy);
794 if (len) goto inf_leave;
796 else if (state->head != Z_NULL)
797 state->head->comment = Z_NULL;
800 if (state->flags & 0x0200) {
802 if (hold != (state->check & 0xffff)) {
803 strm->msg = (char *)"header crc mismatch";
809 if (state->head != Z_NULL) {
810 state->head->hcrc = (int)((state->flags >> 9) & 1);
811 state->head->done = 1;
813 strm->adler = state->check = crc32(0L, Z_NULL, 0);
819 strm->adler = state->check = REVERSE(hold);
823 if (state->havedict == 0) {
827 strm->adler = state->check = adler32(0L, Z_NULL, 0);
830 if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
838 state->last = BITS(1);
841 case 0: /* stored block */
842 Tracev((stderr, "inflate: stored block%s\n",
843 state->last ? " (last)" : ""));
844 state->mode = STORED;
846 case 1: /* fixed block */
848 Tracev((stderr, "inflate: fixed codes block%s\n",
849 state->last ? " (last)" : ""));
850 state->mode = LEN_; /* decode codes */
851 if (flush == Z_TREES) {
856 case 2: /* dynamic block */
857 Tracev((stderr, "inflate: dynamic codes block%s\n",
858 state->last ? " (last)" : ""));
862 strm->msg = (char *)"invalid block type";
868 BYTEBITS(); /* go to byte boundary */
870 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
871 strm->msg = (char *)"invalid stored block lengths";
875 state->length = (unsigned)hold & 0xffff;
876 Tracev((stderr, "inflate: stored length %u\n",
880 if (flush == Z_TREES) goto inf_leave;
884 copy = state->length;
886 if (copy > have) copy = have;
887 if (copy > left) copy = left;
888 if (copy == 0) goto inf_leave;
889 zmemcpy(put, next, copy);
894 state->length -= copy;
897 Tracev((stderr, "inflate: stored end\n"));
902 state->nlen = BITS(5) + 257;
904 state->ndist = BITS(5) + 1;
906 state->ncode = BITS(4) + 4;
908 #ifndef PKZIP_BUG_WORKAROUND
909 if (state->nlen > 286 || state->ndist > 30) {
910 strm->msg = (char *)"too many length or distance symbols";
915 Tracev((stderr, "inflate: table sizes ok\n"));
917 state->mode = LENLENS;
919 while (state->have < state->ncode) {
921 state->lens[order[state->have++]] = (unsigned short)BITS(3);
924 while (state->have < 19)
925 state->lens[order[state->have++]] = 0;
926 state->next = state->codes;
927 state->lencode = (code const FAR *)(state->next);
929 ret = inflate_table(CODES, state->lens, 19, &(state->next),
930 &(state->lenbits), state->work);
932 strm->msg = (char *)"invalid code lengths set";
936 Tracev((stderr, "inflate: code lengths ok\n"));
938 state->mode = CODELENS;
940 while (state->have < state->nlen + state->ndist) {
942 here = state->lencode[BITS(state->lenbits)];
943 if ((unsigned)(here.bits) <= bits) break;
949 state->lens[state->have++] = here.val;
952 if (here.val == 16) {
953 NEEDBITS(here.bits + 2);
955 if (state->have == 0) {
956 strm->msg = (char *)"invalid bit length repeat";
960 len = state->lens[state->have - 1];
964 else if (here.val == 17) {
965 NEEDBITS(here.bits + 3);
972 NEEDBITS(here.bits + 7);
978 if (state->have + copy > state->nlen + state->ndist) {
979 strm->msg = (char *)"invalid bit length repeat";
984 state->lens[state->have++] = (unsigned short)len;
988 /* handle error breaks in while */
989 if (state->mode == BAD) break;
991 /* check for end-of-block code (better have one) */
992 if (state->lens[256] == 0) {
993 strm->msg = (char *)"invalid code -- missing end-of-block";
998 /* build code tables -- note: do not change the lenbits or distbits
999 values here (9 and 6) without reading the comments in inftrees.h
1000 concerning the ENOUGH constants, which depend on those values */
1001 state->next = state->codes;
1002 state->lencode = (code const FAR *)(state->next);
1004 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1005 &(state->lenbits), state->work);
1007 strm->msg = (char *)"invalid literal/lengths set";
1011 state->distcode = (code const FAR *)(state->next);
1012 state->distbits = 6;
1013 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1014 &(state->next), &(state->distbits), state->work);
1016 strm->msg = (char *)"invalid distances set";
1020 Tracev((stderr, "inflate: codes ok\n"));
1022 if (flush == Z_TREES) goto inf_leave;
1026 if (have >= 6 && left >= 258) {
1028 inflate_fast(strm, out);
1030 if (state->mode == TYPE)
1036 here = state->lencode[BITS(state->lenbits)];
1037 if ((unsigned)(here.bits) <= bits) break;
1040 if (here.op && (here.op & 0xf0) == 0) {
1043 here = state->lencode[last.val +
1044 (BITS(last.bits + last.op) >> last.bits)];
1045 if ((unsigned)(last.bits + here.bits) <= bits) break;
1048 DROPBITS(last.bits);
1049 state->back += last.bits;
1051 DROPBITS(here.bits);
1052 state->back += here.bits;
1053 state->length = (unsigned)here.val;
1054 if ((int)(here.op) == 0) {
1055 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
1056 "inflate: literal '%c'\n" :
1057 "inflate: literal 0x%02x\n", here.val));
1062 Tracevv((stderr, "inflate: end of block\n"));
1068 strm->msg = (char *)"invalid literal/length code";
1072 state->extra = (unsigned)(here.op) & 15;
1073 state->mode = LENEXT;
1076 NEEDBITS(state->extra);
1077 state->length += BITS(state->extra);
1078 DROPBITS(state->extra);
1079 state->back += state->extra;
1081 Tracevv((stderr, "inflate: length %u\n", state->length));
1082 state->was = state->length;
1086 here = state->distcode[BITS(state->distbits)];
1087 if ((unsigned)(here.bits) <= bits) break;
1090 if ((here.op & 0xf0) == 0) {
1093 here = state->distcode[last.val +
1094 (BITS(last.bits + last.op) >> last.bits)];
1095 if ((unsigned)(last.bits + here.bits) <= bits) break;
1098 DROPBITS(last.bits);
1099 state->back += last.bits;
1101 DROPBITS(here.bits);
1102 state->back += here.bits;
1104 strm->msg = (char *)"invalid distance code";
1108 state->offset = (unsigned)here.val;
1109 state->extra = (unsigned)(here.op) & 15;
1110 state->mode = DISTEXT;
1113 NEEDBITS(state->extra);
1114 state->offset += BITS(state->extra);
1115 DROPBITS(state->extra);
1116 state->back += state->extra;
1118 #ifdef INFLATE_STRICT
1119 if (state->offset > state->dmax) {
1120 strm->msg = (char *)"invalid distance too far back";
1125 Tracevv((stderr, "inflate: distance %u\n", state->offset));
1126 state->mode = MATCH;
1128 if (left == 0) goto inf_leave;
1130 if (state->offset > copy) { /* copy from window */
1131 copy = state->offset - copy;
1132 if (copy > state->whave) {
1134 strm->msg = (char *)"invalid distance too far back";
1138 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
1139 Trace((stderr, "inflate.c too far\n"));
1140 copy -= state->whave;
1141 if (copy > state->length) copy = state->length;
1142 if (copy > left) copy = left;
1144 state->length -= copy;
1148 if (state->length == 0) state->mode = LEN;
1152 if (copy > state->wnext) {
1153 copy -= state->wnext;
1154 from = state->window + (state->wsize - copy);
1157 from = state->window + (state->wnext - copy);
1158 if (copy > state->length) copy = state->length;
1160 else { /* copy from output */
1161 from = put - state->offset;
1162 copy = state->length;
1164 if (copy > left) copy = left;
1166 state->length -= copy;
1170 if (state->length == 0) state->mode = LEN;
1173 if (left == 0) goto inf_leave;
1174 *put++ = (unsigned char)(state->length);
1182 strm->total_out += out;
1183 state->total += out;
1185 strm->adler = state->check =
1186 UPDATE(state->check, put - out, out);
1190 state->flags ? hold :
1192 REVERSE(hold)) != state->check) {
1193 strm->msg = (char *)"incorrect data check";
1198 Tracev((stderr, "inflate: check matches trailer\n"));
1201 state->mode = LENGTH;
1203 if (state->wrap && state->flags) {
1205 if (hold != (state->total & 0xffffffffUL)) {
1206 strm->msg = (char *)"incorrect length check";
1211 Tracev((stderr, "inflate: length matches trailer\n"));
1225 return Z_STREAM_ERROR;
1229 Return from inflate(), updating the total counts and the check value.
1230 If there was no progress during the inflate() call, return a buffer
1231 error. Call updatewindow() to create and/or update the window state.
1232 Note: a memory error from inflate() is non-recoverable.
1236 if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
1237 if (updatewindow(strm, out)) {
1241 in -= strm->avail_in;
1242 out -= strm->avail_out;
1243 strm->total_in += in;
1244 strm->total_out += out;
1245 state->total += out;
1246 if (state->wrap && out)
1247 strm->adler = state->check =
1248 UPDATE(state->check, strm->next_out - out, out);
1249 strm->data_type = state->bits + (state->last ? 64 : 0) +
1250 (state->mode == TYPE ? 128 : 0) +
1251 (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
1252 if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1257 int ZEXPORT inflateEnd(strm)
1260 struct inflate_state FAR *state;
1261 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
1262 return Z_STREAM_ERROR;
1263 state = (struct inflate_state FAR *)strm->state;
1264 if (state->window != Z_NULL) ZFREE(strm, state->window);
1265 ZFREE(strm, strm->state);
1266 strm->state = Z_NULL;
1267 Tracev((stderr, "inflate: end\n"));
1271 int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
1273 const Bytef *dictionary;
1276 struct inflate_state FAR *state;
1280 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1281 state = (struct inflate_state FAR *)strm->state;
1282 if (state->wrap != 0 && state->mode != DICT)
1283 return Z_STREAM_ERROR;
1285 /* check for correct dictionary id */
1286 if (state->mode == DICT) {
1287 id = adler32(0L, Z_NULL, 0);
1288 id = adler32(id, dictionary, dictLength);
1289 if (id != state->check)
1290 return Z_DATA_ERROR;
1293 /* copy dictionary to window */
1294 if (updatewindow(strm, strm->avail_out)) {
1298 if (dictLength > state->wsize) {
1299 zmemcpy(state->window, dictionary + dictLength - state->wsize,
1301 state->whave = state->wsize;
1304 zmemcpy(state->window + state->wsize - dictLength, dictionary,
1306 state->whave = dictLength;
1308 state->havedict = 1;
1309 Tracev((stderr, "inflate: dictionary set\n"));
1313 int ZEXPORT inflateGetHeader(strm, head)
1317 struct inflate_state FAR *state;
1320 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1321 state = (struct inflate_state FAR *)strm->state;
1322 if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1324 /* save header structure */
1331 Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
1332 or when out of input. When called, *have is the number of pattern bytes
1333 found in order so far, in 0..3. On return *have is updated to the new
1334 state. If on return *have equals four, then the pattern was found and the
1335 return value is how many bytes were read including the last byte of the
1336 pattern. If *have is less than four, then the pattern has not been found
1337 yet and the return value is len. In the latter case, syncsearch() can be
1338 called again with more data and the *have state. *have is initialized to
1339 zero for the first call.
1341 local unsigned syncsearch(have, buf, len)
1343 unsigned char FAR *buf;
1351 while (next < len && got < 4) {
1352 if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
1364 int ZEXPORT inflateSync(strm)
1367 unsigned len; /* number of bytes to look at or looked at */
1368 unsigned long in, out; /* temporary to save total_in and total_out */
1369 unsigned char buf[4]; /* to restore bit buffer to byte string */
1370 struct inflate_state FAR *state;
1372 /* check parameters */
1373 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1374 state = (struct inflate_state FAR *)strm->state;
1375 if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1377 /* if first time, start search in bit buffer */
1378 if (state->mode != SYNC) {
1380 state->hold <<= state->bits & 7;
1381 state->bits -= state->bits & 7;
1383 while (state->bits >= 8) {
1384 buf[len++] = (unsigned char)(state->hold);
1389 syncsearch(&(state->have), buf, len);
1392 /* search available input */
1393 len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1394 strm->avail_in -= len;
1395 strm->next_in += len;
1396 strm->total_in += len;
1398 /* return no joy or set up to restart inflate() on a new block */
1399 if (state->have != 4) return Z_DATA_ERROR;
1400 in = strm->total_in; out = strm->total_out;
1402 strm->total_in = in; strm->total_out = out;
1408 Returns true if inflate is currently at the end of a block generated by
1409 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
1410 implementation to provide an additional safety check. PPP uses
1411 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
1412 block. When decompressing, PPP checks that at the end of input packet,
1413 inflate is waiting for these length bytes.
1415 int ZEXPORT inflateSyncPoint(strm)
1418 struct inflate_state FAR *state;
1420 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1421 state = (struct inflate_state FAR *)strm->state;
1422 return state->mode == STORED && state->bits == 0;
1425 int ZEXPORT inflateCopy(dest, source)
1429 struct inflate_state FAR *state;
1430 struct inflate_state FAR *copy;
1431 unsigned char FAR *window;
1435 if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
1436 source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
1437 return Z_STREAM_ERROR;
1438 state = (struct inflate_state FAR *)source->state;
1440 /* allocate space */
1441 copy = (struct inflate_state FAR *)
1442 ZALLOC(source, 1, sizeof(struct inflate_state));
1443 if (copy == Z_NULL) return Z_MEM_ERROR;
1445 if (state->window != Z_NULL) {
1446 window = (unsigned char FAR *)
1447 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1448 if (window == Z_NULL) {
1449 ZFREE(source, copy);
1455 zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
1456 zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
1457 if (state->lencode >= state->codes &&
1458 state->lencode <= state->codes + ENOUGH - 1) {
1459 copy->lencode = copy->codes + (state->lencode - state->codes);
1460 copy->distcode = copy->codes + (state->distcode - state->codes);
1462 copy->next = copy->codes + (state->next - state->codes);
1463 if (window != Z_NULL) {
1464 wsize = 1U << state->wbits;
1465 zmemcpy(window, state->window, wsize);
1467 copy->window = window;
1468 dest->state = (struct internal_state FAR *)copy;
1472 int ZEXPORT inflateUndermine(strm, subvert)
1476 struct inflate_state FAR *state;
1478 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1479 state = (struct inflate_state FAR *)strm->state;
1480 state->sane = !subvert;
1481 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
1485 return Z_DATA_ERROR;
1489 long ZEXPORT inflateMark(strm)
1492 struct inflate_state FAR *state;
1494 if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
1495 state = (struct inflate_state FAR *)strm->state;
1496 return ((long)(state->back) << 16) +
1497 (state->mode == COPY ? state->length :
1498 (state->mode == MATCH ? state->was - state->length : 0));