]>
git.zerfleddert.de Git - proxmark3-svn/blob - zlib/inflate.c
1 /* inflate.c -- zlib decompression
2 * Copyright (C) 1995-2012 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.
83 //-----------------------------------------------------------------------------
84 // This version of zlib is modified for use within the Proxmark3 project.
85 // Files from the original distribution which are not required for this
86 // purpose are not included. All modifications can easily be found
87 // by searching for #ifdef ZLIB_PM3_TUNED and #ifndef ZLIB_PM3_TUNED.
88 //-----------------------------------------------------------------------------
103 /* function prototypes */
104 #ifdef ZLIB_PM3_TUNED
105 extern void Dbprintf(const char *fmt
, ...);
107 local
void fixedtables
OF((struct inflate_state FAR
*state
));
109 local
int updatewindow
OF((z_streamp strm
, const unsigned char FAR
*end
,
112 void makefixed
OF((void));
114 local
unsigned syncsearch
OF((unsigned FAR
*have
, const unsigned char FAR
*buf
,
117 int ZEXPORT
inflateResetKeep(strm
)
120 struct inflate_state FAR
*state
;
122 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
) return Z_STREAM_ERROR
;
123 state
= (struct inflate_state FAR
*)strm
->state
;
124 strm
->total_in
= strm
->total_out
= state
->total
= 0;
126 if (state
->wrap
) /* to support ill-conceived Java test suite */
127 strm
->adler
= state
->wrap
& 1;
131 state
->dmax
= 32768U;
132 state
->head
= Z_NULL
;
135 state
->lencode
= state
->distcode
= state
->next
= state
->codes
;
138 Tracev((stderr
, "inflate: reset\n"));
142 int ZEXPORT
inflateReset(strm
)
145 struct inflate_state FAR
*state
;
147 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
) return Z_STREAM_ERROR
;
148 state
= (struct inflate_state FAR
*)strm
->state
;
152 return inflateResetKeep(strm
);
155 int ZEXPORT
inflateReset2(strm
, windowBits
)
160 struct inflate_state FAR
*state
;
163 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
) return Z_STREAM_ERROR
;
164 state
= (struct inflate_state FAR
*)strm
->state
;
166 /* extract wrap request from windowBits parameter */
167 if (windowBits
< 0) {
169 windowBits
= -windowBits
;
172 wrap
= (windowBits
>> 4) + 1;
179 /* set number of window bits, free window if different */
180 if (windowBits
&& (windowBits
< 8 || windowBits
> 15))
181 return Z_STREAM_ERROR
;
182 if (state
->window
!= Z_NULL
&& state
->wbits
!= (unsigned)windowBits
) {
183 ZFREE(strm
, state
->window
);
184 state
->window
= Z_NULL
;
187 /* update state and reset the rest of it */
189 state
->wbits
= (unsigned)windowBits
;
190 return inflateReset(strm
);
193 int ZEXPORT
inflateInit2_(strm
, windowBits
, version
, stream_size
)
200 struct inflate_state FAR
*state
;
202 if (version
== Z_NULL
|| version
[0] != ZLIB_VERSION
[0] ||
203 stream_size
!= (int)(sizeof(z_stream
)))
204 return Z_VERSION_ERROR
;
205 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
206 strm
->msg
= Z_NULL
; /* in case we return an error */
207 if (strm
->zalloc
== (alloc_func
)0) {
209 return Z_STREAM_ERROR
;
211 strm
->zalloc
= zcalloc
;
212 strm
->opaque
= (voidpf
)0;
215 if (strm
->zfree
== (free_func
)0)
217 return Z_STREAM_ERROR
;
219 strm
->zfree
= zcfree
;
221 state
= (struct inflate_state FAR
*)
222 ZALLOC(strm
, 1, sizeof(struct inflate_state
));
223 if (state
== Z_NULL
) return Z_MEM_ERROR
;
224 Tracev((stderr
, "inflate: allocated\n"));
225 strm
->state
= (struct internal_state FAR
*)state
;
226 state
->window
= Z_NULL
;
227 ret
= inflateReset2(strm
, windowBits
);
230 strm
->state
= Z_NULL
;
235 int ZEXPORT
inflateInit_(strm
, version
, stream_size
)
240 return inflateInit2_(strm
, DEF_WBITS
, version
, stream_size
);
243 int ZEXPORT
inflatePrime(strm
, bits
, value
)
248 struct inflate_state FAR
*state
;
250 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
) return Z_STREAM_ERROR
;
251 state
= (struct inflate_state FAR
*)strm
->state
;
257 if (bits
> 16 || state
->bits
+ bits
> 32) return Z_STREAM_ERROR
;
258 value
&= (1L << bits
) - 1;
259 state
->hold
+= value
<< state
->bits
;
265 Return state with length and distance decoding tables and index sizes set to
266 fixed code decoding. Normally this returns fixed tables from inffixed.h.
267 If BUILDFIXED is defined, then instead this routine builds the tables the
268 first time it's called, and returns those tables the first time and
269 thereafter. This reduces the size of the code by about 2K bytes, in
270 exchange for a little execution time. However, BUILDFIXED should not be
271 used for threaded applications, since the rewriting of the tables and virgin
272 may not be thread-safe.
274 #ifndef ZLIB_PM3_TUNED
275 local
void fixedtables(state
)
276 struct inflate_state FAR
*state
;
279 static int virgin
= 1;
280 static code
*lenfix
, *distfix
;
281 static code fixed
[544];
283 /* build fixed huffman tables if first call (may not be thread safe) */
288 /* literal/length table */
290 while (sym
< 144) state
->lens
[sym
++] = 8;
291 while (sym
< 256) state
->lens
[sym
++] = 9;
292 while (sym
< 280) state
->lens
[sym
++] = 7;
293 while (sym
< 288) state
->lens
[sym
++] = 8;
297 inflate_table(LENS
, state
->lens
, 288, &(next
), &(bits
), state
->work
);
301 while (sym
< 32) state
->lens
[sym
++] = 5;
304 inflate_table(DISTS
, state
->lens
, 32, &(next
), &(bits
), state
->work
);
306 /* do this just once */
309 #else /* !BUILDFIXED */
310 # include "inffixed.h"
311 #endif /* BUILDFIXED */
312 state
->lencode
= lenfix
;
314 state
->distcode
= distfix
;
322 Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also
323 defines BUILDFIXED, so the tables are built on the fly. makefixed() writes
324 those tables to stdout, which would be piped to inffixed.h. A small program
325 can simply call makefixed to do this:
327 void makefixed(void);
335 Then that can be linked with zlib built with MAKEFIXED defined and run:
342 struct inflate_state state
;
345 puts(" /* inffixed.h -- table for decoding fixed codes");
346 puts(" * Generated automatically by makefixed().");
349 puts(" /* WARNING: this file should *not* be used by applications.");
350 puts(" It is part of the implementation of this library and is");
351 puts(" subject to change. Applications should only use zlib.h.");
355 printf(" static const code lenfix[%u] = {", size
);
358 if ((low
% 7) == 0) printf("\n ");
359 printf("{%u,%u,%d}", (low
& 127) == 99 ? 64 : state
.lencode
[low
].op
,
360 state
.lencode
[low
].bits
, state
.lencode
[low
].val
);
361 if (++low
== size
) break;
366 printf("\n static const code distfix[%u] = {", size
);
369 if ((low
% 6) == 0) printf("\n ");
370 printf("{%u,%u,%d}", state
.distcode
[low
].op
, state
.distcode
[low
].bits
,
371 state
.distcode
[low
].val
);
372 if (++low
== size
) break;
377 #endif /* MAKEFIXED */
378 #endif /* ZLIB_PM3_TUNED */
380 Update the window with the last wsize (normally 32K) bytes written before
381 returning. If window does not exist yet, create it. This is only called
382 when a window is already in use, or when output has been written during this
383 inflate call, but the end of the deflate stream has not been reached yet.
384 It is also called to create a window for dictionary data when a dictionary
387 Providing output buffers larger than 32K to inflate() should provide a speed
388 advantage, since only the last 32K of output is copied to the sliding window
389 upon return from inflate(), and since all distances after the first 32K of
390 output will fall in the output data, making match copies simpler and faster.
391 The advantage may be dependent on the size of the processor's data caches.
393 local
int updatewindow(strm
, end
, copy
)
398 struct inflate_state FAR
*state
;
401 state
= (struct inflate_state FAR
*)strm
->state
;
403 /* if it hasn't been done already, allocate space for the window */
404 if (state
->window
== Z_NULL
) {
405 state
->window
= (unsigned char FAR
*)
406 ZALLOC(strm
, 1U << state
->wbits
,
407 sizeof(unsigned char));
408 if (state
->window
== Z_NULL
) return 1;
411 /* if window not in use yet, initialize */
412 if (state
->wsize
== 0) {
413 state
->wsize
= 1U << state
->wbits
;
418 /* copy state->wsize or less output bytes into the circular window */
419 if (copy
>= state
->wsize
) {
420 zmemcpy(state
->window
, end
- state
->wsize
, state
->wsize
);
422 state
->whave
= state
->wsize
;
425 dist
= state
->wsize
- state
->wnext
;
426 if (dist
> copy
) dist
= copy
;
427 zmemcpy(state
->window
+ state
->wnext
, end
- copy
, dist
);
430 zmemcpy(state
->window
, end
- copy
, copy
);
432 state
->whave
= state
->wsize
;
435 state
->wnext
+= dist
;
436 if (state
->wnext
== state
->wsize
) state
->wnext
= 0;
437 if (state
->whave
< state
->wsize
) state
->whave
+= dist
;
443 /* Macros for inflate(): */
445 /* check function to use adler32() for zlib or crc32() for gzip */
447 # define UPDATE(check, buf, len) \
448 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
450 # define UPDATE(check, buf, len) adler32(check, buf, len)
453 /* check macros for header crc */
455 # define CRC2(check, word) \
457 hbuf[0] = (unsigned char)(word); \
458 hbuf[1] = (unsigned char)((word) >> 8); \
459 check = crc32(check, hbuf, 2); \
462 # define CRC4(check, word) \
464 hbuf[0] = (unsigned char)(word); \
465 hbuf[1] = (unsigned char)((word) >> 8); \
466 hbuf[2] = (unsigned char)((word) >> 16); \
467 hbuf[3] = (unsigned char)((word) >> 24); \
468 check = crc32(check, hbuf, 4); \
472 /* Load registers with state in inflate() for speed */
475 put = strm->next_out; \
476 left = strm->avail_out; \
477 next = strm->next_in; \
478 have = strm->avail_in; \
479 hold = state->hold; \
480 bits = state->bits; \
483 /* Restore state from registers in inflate() */
486 strm->next_out = put; \
487 strm->avail_out = left; \
488 strm->next_in = next; \
489 strm->avail_in = have; \
490 state->hold = hold; \
491 state->bits = bits; \
494 /* Clear the input bit accumulator */
501 /* Get a byte of input into the bit accumulator, or return from inflate()
502 if there is no input available. */
505 if (have == 0) goto inf_leave; \
507 hold += (unsigned long)(*next++) << bits; \
511 /* Assure that there are at least n bits in the bit accumulator. If there is
512 not enough available input to do that, then return from inflate(). */
513 #define NEEDBITS(n) \
515 while (bits < (unsigned)(n)) \
519 /* Return the low n bits of the bit accumulator (n < 16) */
521 ((unsigned)hold & ((1U << (n)) - 1))
523 /* Remove n bits from the bit accumulator */
524 #define DROPBITS(n) \
527 bits -= (unsigned)(n); \
530 /* Remove zero to seven bits as needed to go to a byte boundary */
538 inflate() uses a state machine to process as much input data and generate as
539 much output data as possible before returning. The state machine is
540 structured roughly as follows:
542 for (;;) switch (state) {
545 if (not enough input data or output space to make progress)
547 ... make progress ...
553 so when inflate() is called again, the same case is attempted again, and
554 if the appropriate resources are provided, the machine proceeds to the
555 next state. The NEEDBITS() macro is usually the way the state evaluates
556 whether it can proceed or should return. NEEDBITS() does the return if
557 the requested bits are not available. The typical use of the BITS macros
561 ... do something with BITS(n) ...
564 where NEEDBITS(n) either returns from inflate() if there isn't enough
565 input left to load n bits into the accumulator, or it continues. BITS(n)
566 gives the low n bits in the accumulator. When done, DROPBITS(n) drops
567 the low n bits off the accumulator. INITBITS() clears the accumulator
568 and sets the number of available bits to zero. BYTEBITS() discards just
569 enough bits to put the accumulator on a byte boundary. After BYTEBITS()
570 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
572 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
573 if there is no input available. The decoding of variable length codes uses
574 PULLBYTE() directly in order to pull just enough bytes to decode the next
577 Some states loop until they get enough input, making sure that enough
578 state information is maintained to continue the loop where it left off
579 if NEEDBITS() returns in the loop. For example, want, need, and keep
580 would all have to actually be part of the saved state in case NEEDBITS()
584 while (want < need) {
586 keep[want++] = BITS(n);
592 As shown above, if the next state is also the next case, then the break
595 A state may also return if there is not enough output space available to
596 complete that state. Those states are copying stored data, writing a
597 literal byte, and copying a matching string.
599 When returning, a "goto inf_leave" is used to update the total counters,
600 update the check value, and determine whether any progress has been made
601 during that inflate() call in order to return the proper return code.
602 Progress is defined as a change in either strm->avail_in or strm->avail_out.
603 When there is a window, goto inf_leave will update the window with the last
604 output written. If a goto inf_leave occurs in the middle of decompression
605 and there is no window currently, goto inf_leave will create one and copy
606 output to the window for the next call of inflate().
608 In this implementation, the flush parameter of inflate() only affects the
609 return code (per zlib.h). inflate() always writes as much as possible to
610 strm->next_out, given the space available and the provided input--the effect
611 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
612 the allocation of and copying into a sliding window until necessary, which
613 provides the effect documented in zlib.h for Z_FINISH when the entire input
614 stream available. So the only thing the flush parameter actually does is:
615 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
616 will return Z_BUF_ERROR if it has not reached the end of the stream.
619 int ZEXPORT
inflate(strm
, flush
)
623 struct inflate_state FAR
*state
;
624 z_const
unsigned char FAR
*next
; /* next input */
625 unsigned char FAR
*put
; /* next output */
626 unsigned have
, left
; /* available input and output */
627 unsigned long hold
; /* bit buffer */
628 unsigned bits
; /* bits in bit buffer */
629 unsigned in
, out
; /* save starting available input and output */
630 unsigned copy
; /* number of stored or match bytes to copy */
631 unsigned char FAR
*from
; /* where to copy match bytes from */
632 code here
; /* current decoding table entry */
633 code last
; /* parent table entry */
634 unsigned len
; /* length to copy for repeats, bits to drop */
635 int ret
; /* return code */
637 unsigned char hbuf
[4]; /* buffer for gzip header crc calculation */
639 static const unsigned short order
[19] = /* permutation of code lengths */
640 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
642 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
|| strm
->next_out
== Z_NULL
||
643 (strm
->next_in
== Z_NULL
&& strm
->avail_in
!= 0))
644 return Z_STREAM_ERROR
;
646 state
= (struct inflate_state FAR
*)strm
->state
;
647 if (state
->mode
== TYPE
) state
->mode
= TYPEDO
; /* skip check */
653 switch (state
->mode
) {
655 if (state
->wrap
== 0) {
656 state
->mode
= TYPEDO
;
661 if ((state
->wrap
& 2) && hold
== 0x8b1f) { /* gzip header */
662 state
->check
= crc32(0L, Z_NULL
, 0);
663 CRC2(state
->check
, hold
);
668 state
->flags
= 0; /* expect zlib header */
669 if (state
->head
!= Z_NULL
)
670 state
->head
->done
= -1;
671 if (!(state
->wrap
& 1) || /* check if zlib header allowed */
675 ((BITS(8) << 8) + (hold
>> 8)) % 31) {
676 strm
->msg
= (char *)"incorrect header check";
680 if (BITS(4) != Z_DEFLATED
) {
681 strm
->msg
= (char *)"unknown compression method";
687 if (state
->wbits
== 0)
689 else if (len
> state
->wbits
) {
690 strm
->msg
= (char *)"invalid window size";
694 state
->dmax
= 1U << len
;
695 Tracev((stderr
, "inflate: zlib header ok\n"));
696 strm
->adler
= state
->check
= adler32(0L, Z_NULL
, 0);
697 state
->mode
= hold
& 0x200 ? DICTID
: TYPE
;
703 state
->flags
= (int)(hold
);
704 if ((state
->flags
& 0xff) != Z_DEFLATED
) {
705 strm
->msg
= (char *)"unknown compression method";
709 if (state
->flags
& 0xe000) {
710 strm
->msg
= (char *)"unknown header flags set";
714 if (state
->head
!= Z_NULL
)
715 state
->head
->text
= (int)((hold
>> 8) & 1);
716 if (state
->flags
& 0x0200) CRC2(state
->check
, hold
);
721 if (state
->head
!= Z_NULL
)
722 state
->head
->time
= hold
;
723 if (state
->flags
& 0x0200) CRC4(state
->check
, hold
);
728 if (state
->head
!= Z_NULL
) {
729 state
->head
->xflags
= (int)(hold
& 0xff);
730 state
->head
->os
= (int)(hold
>> 8);
732 if (state
->flags
& 0x0200) CRC2(state
->check
, hold
);
736 if (state
->flags
& 0x0400) {
738 state
->length
= (unsigned)(hold
);
739 if (state
->head
!= Z_NULL
)
740 state
->head
->extra_len
= (unsigned)hold
;
741 if (state
->flags
& 0x0200) CRC2(state
->check
, hold
);
744 else if (state
->head
!= Z_NULL
)
745 state
->head
->extra
= Z_NULL
;
748 if (state
->flags
& 0x0400) {
749 copy
= state
->length
;
750 if (copy
> have
) copy
= have
;
752 if (state
->head
!= Z_NULL
&&
753 state
->head
->extra
!= Z_NULL
) {
754 len
= state
->head
->extra_len
- state
->length
;
755 zmemcpy(state
->head
->extra
+ len
, next
,
756 len
+ copy
> state
->head
->extra_max
?
757 state
->head
->extra_max
- len
: copy
);
759 if (state
->flags
& 0x0200)
760 state
->check
= crc32(state
->check
, next
, copy
);
763 state
->length
-= copy
;
765 if (state
->length
) goto inf_leave
;
770 if (state
->flags
& 0x0800) {
771 if (have
== 0) goto inf_leave
;
774 len
= (unsigned)(next
[copy
++]);
775 if (state
->head
!= Z_NULL
&&
776 state
->head
->name
!= Z_NULL
&&
777 state
->length
< state
->head
->name_max
)
778 state
->head
->name
[state
->length
++] = len
;
779 } while (len
&& copy
< have
);
780 if (state
->flags
& 0x0200)
781 state
->check
= crc32(state
->check
, next
, copy
);
784 if (len
) goto inf_leave
;
786 else if (state
->head
!= Z_NULL
)
787 state
->head
->name
= Z_NULL
;
789 state
->mode
= COMMENT
;
791 if (state
->flags
& 0x1000) {
792 if (have
== 0) goto inf_leave
;
795 len
= (unsigned)(next
[copy
++]);
796 if (state
->head
!= Z_NULL
&&
797 state
->head
->comment
!= Z_NULL
&&
798 state
->length
< state
->head
->comm_max
)
799 state
->head
->comment
[state
->length
++] = len
;
800 } while (len
&& copy
< have
);
801 if (state
->flags
& 0x0200)
802 state
->check
= crc32(state
->check
, next
, copy
);
805 if (len
) goto inf_leave
;
807 else if (state
->head
!= Z_NULL
)
808 state
->head
->comment
= Z_NULL
;
811 if (state
->flags
& 0x0200) {
813 if (hold
!= (state
->check
& 0xffff)) {
814 strm
->msg
= (char *)"header crc mismatch";
820 if (state
->head
!= Z_NULL
) {
821 state
->head
->hcrc
= (int)((state
->flags
>> 9) & 1);
822 state
->head
->done
= 1;
824 strm
->adler
= state
->check
= crc32(0L, Z_NULL
, 0);
830 strm
->adler
= state
->check
= ZSWAP32(hold
);
834 if (state
->havedict
== 0) {
838 strm
->adler
= state
->check
= adler32(0L, Z_NULL
, 0);
841 if (flush
== Z_BLOCK
|| flush
== Z_TREES
) goto inf_leave
;
849 state
->last
= BITS(1);
852 case 0: /* stored block */
853 Tracev((stderr
, "inflate: stored block%s\n",
854 state
->last
? " (last)" : ""));
855 state
->mode
= STORED
;
857 case 1: /* fixed block */
858 #ifdef ZLIB_PM3_TUNED
859 strm
->msg
= (char *)"fixed block coding not supported";
863 Tracev((stderr
, "inflate: fixed codes block%s\n",
864 state
->last
? " (last)" : ""));
865 state
->mode
= LEN_
; /* decode codes */
866 if (flush
== Z_TREES
) {
872 case 2: /* dynamic block */
873 Tracev((stderr
, "inflate: dynamic codes block%s\n",
874 state
->last
? " (last)" : ""));
878 strm
->msg
= (char *)"invalid block type";
884 BYTEBITS(); /* go to byte boundary */
886 if ((hold
& 0xffff) != ((hold
>> 16) ^ 0xffff)) {
887 strm
->msg
= (char *)"invalid stored block lengths";
891 state
->length
= (unsigned)hold
& 0xffff;
892 Tracev((stderr
, "inflate: stored length %u\n",
896 if (flush
== Z_TREES
) goto inf_leave
;
900 copy
= state
->length
;
902 if (copy
> have
) copy
= have
;
903 if (copy
> left
) copy
= left
;
904 if (copy
== 0) goto inf_leave
;
905 zmemcpy(put
, next
, copy
);
910 state
->length
-= copy
;
913 Tracev((stderr
, "inflate: stored end\n"));
918 state
->nlen
= BITS(5) + 257;
920 state
->ndist
= BITS(5) + 1;
922 state
->ncode
= BITS(4) + 4;
924 #ifndef PKZIP_BUG_WORKAROUND
925 if (state
->nlen
> 286 || state
->ndist
> 30) {
926 strm
->msg
= (char *)"too many length or distance symbols";
931 Tracev((stderr
, "inflate: table sizes ok\n"));
933 state
->mode
= LENLENS
;
935 while (state
->have
< state
->ncode
) {
937 state
->lens
[order
[state
->have
++]] = (unsigned short)BITS(3);
940 while (state
->have
< 19)
941 state
->lens
[order
[state
->have
++]] = 0;
942 state
->next
= state
->codes
;
943 state
->lencode
= (const code FAR
*)(state
->next
);
945 ret
= inflate_table(CODES
, state
->lens
, 19, &(state
->next
),
946 &(state
->lenbits
), state
->work
);
948 strm
->msg
= (char *)"invalid code lengths set";
952 Tracev((stderr
, "inflate: code lengths ok\n"));
954 state
->mode
= CODELENS
;
956 while (state
->have
< state
->nlen
+ state
->ndist
) {
958 here
= state
->lencode
[BITS(state
->lenbits
)];
959 if ((unsigned)(here
.bits
) <= bits
) break;
964 state
->lens
[state
->have
++] = here
.val
;
967 if (here
.val
== 16) {
968 NEEDBITS(here
.bits
+ 2);
970 if (state
->have
== 0) {
971 strm
->msg
= (char *)"invalid bit length repeat";
975 len
= state
->lens
[state
->have
- 1];
979 else if (here
.val
== 17) {
980 NEEDBITS(here
.bits
+ 3);
987 NEEDBITS(here
.bits
+ 7);
993 if (state
->have
+ copy
> state
->nlen
+ state
->ndist
) {
994 strm
->msg
= (char *)"invalid bit length repeat";
999 state
->lens
[state
->have
++] = (unsigned short)len
;
1003 /* handle error breaks in while */
1004 if (state
->mode
== BAD
) break;
1006 /* check for end-of-block code (better have one) */
1007 if (state
->lens
[256] == 0) {
1008 strm
->msg
= (char *)"invalid code -- missing end-of-block";
1013 /* build code tables -- note: do not change the lenbits or distbits
1014 values here (9 and 6) without reading the comments in inftrees.h
1015 concerning the ENOUGH constants, which depend on those values */
1016 state
->next
= state
->codes
;
1017 state
->lencode
= (const code FAR
*)(state
->next
);
1019 ret
= inflate_table(LENS
, state
->lens
, state
->nlen
, &(state
->next
),
1020 &(state
->lenbits
), state
->work
);
1022 strm
->msg
= (char *)"invalid literal/lengths set";
1026 state
->distcode
= (const code FAR
*)(state
->next
);
1027 state
->distbits
= 6;
1028 ret
= inflate_table(DISTS
, state
->lens
+ state
->nlen
, state
->ndist
,
1029 &(state
->next
), &(state
->distbits
), state
->work
);
1031 strm
->msg
= (char *)"invalid distances set";
1035 Tracev((stderr
, "inflate: codes ok\n"));
1037 if (flush
== Z_TREES
) goto inf_leave
;
1041 if (have
>= 6 && left
>= 258) {
1043 inflate_fast(strm
, out
);
1045 if (state
->mode
== TYPE
)
1051 here
= state
->lencode
[BITS(state
->lenbits
)];
1052 if ((unsigned)(here
.bits
) <= bits
) break;
1055 if (here
.op
&& (here
.op
& 0xf0) == 0) {
1058 here
= state
->lencode
[last
.val
+
1059 (BITS(last
.bits
+ last
.op
) >> last
.bits
)];
1060 if ((unsigned)(last
.bits
+ here
.bits
) <= bits
) break;
1063 DROPBITS(last
.bits
);
1064 state
->back
+= last
.bits
;
1066 DROPBITS(here
.bits
);
1067 state
->back
+= here
.bits
;
1068 state
->length
= (unsigned)here
.val
;
1069 if ((int)(here
.op
) == 0) {
1070 Tracevv((stderr
, here
.val
>= 0x20 && here
.val
< 0x7f ?
1071 "inflate: literal '%c'\n" :
1072 "inflate: literal 0x%02x\n", here
.val
));
1077 Tracevv((stderr
, "inflate: end of block\n"));
1083 strm
->msg
= (char *)"invalid literal/length code";
1087 state
->extra
= (unsigned)(here
.op
) & 15;
1088 state
->mode
= LENEXT
;
1091 NEEDBITS(state
->extra
);
1092 state
->length
+= BITS(state
->extra
);
1093 DROPBITS(state
->extra
);
1094 state
->back
+= state
->extra
;
1096 Tracevv((stderr
, "inflate: length %u\n", state
->length
));
1097 state
->was
= state
->length
;
1101 here
= state
->distcode
[BITS(state
->distbits
)];
1102 if ((unsigned)(here
.bits
) <= bits
) break;
1105 if ((here
.op
& 0xf0) == 0) {
1108 here
= state
->distcode
[last
.val
+
1109 (BITS(last
.bits
+ last
.op
) >> last
.bits
)];
1110 if ((unsigned)(last
.bits
+ here
.bits
) <= bits
) break;
1113 DROPBITS(last
.bits
);
1114 state
->back
+= last
.bits
;
1116 DROPBITS(here
.bits
);
1117 state
->back
+= here
.bits
;
1119 strm
->msg
= (char *)"invalid distance code";
1123 state
->offset
= (unsigned)here
.val
;
1124 state
->extra
= (unsigned)(here
.op
) & 15;
1125 state
->mode
= DISTEXT
;
1128 NEEDBITS(state
->extra
);
1129 state
->offset
+= BITS(state
->extra
);
1130 DROPBITS(state
->extra
);
1131 state
->back
+= state
->extra
;
1133 #ifdef INFLATE_STRICT
1134 if (state
->offset
> state
->dmax
) {
1135 strm
->msg
= (char *)"invalid distance too far back";
1140 Tracevv((stderr
, "inflate: distance %u\n", state
->offset
));
1141 state
->mode
= MATCH
;
1143 if (left
== 0) goto inf_leave
;
1145 if (state
->offset
> copy
) { /* copy from window */
1146 copy
= state
->offset
- copy
;
1147 if (copy
> state
->whave
) {
1149 strm
->msg
= (char *)"invalid distance too far back";
1153 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
1154 Trace((stderr
, "inflate.c too far\n"));
1155 copy
-= state
->whave
;
1156 if (copy
> state
->length
) copy
= state
->length
;
1157 if (copy
> left
) copy
= left
;
1159 state
->length
-= copy
;
1163 if (state
->length
== 0) state
->mode
= LEN
;
1167 if (copy
> state
->wnext
) {
1168 copy
-= state
->wnext
;
1169 from
= state
->window
+ (state
->wsize
- copy
);
1172 from
= state
->window
+ (state
->wnext
- copy
);
1173 if (copy
> state
->length
) copy
= state
->length
;
1175 else { /* copy from output */
1176 from
= put
- state
->offset
;
1177 copy
= state
->length
;
1179 if (copy
> left
) copy
= left
;
1181 state
->length
-= copy
;
1185 if (state
->length
== 0) state
->mode
= LEN
;
1188 if (left
== 0) goto inf_leave
;
1189 *put
++ = (unsigned char)(state
->length
);
1197 strm
->total_out
+= out
;
1198 state
->total
+= out
;
1200 strm
->adler
= state
->check
=
1201 UPDATE(state
->check
, put
- out
, out
);
1205 state
->flags
? hold
:
1207 ZSWAP32(hold
)) != state
->check
) {
1208 strm
->msg
= (char *)"incorrect data check";
1213 Tracev((stderr
, "inflate: check matches trailer\n"));
1216 state
->mode
= LENGTH
;
1218 if (state
->wrap
&& state
->flags
) {
1220 if (hold
!= (state
->total
& 0xffffffffUL
)) {
1221 strm
->msg
= (char *)"incorrect length check";
1226 Tracev((stderr
, "inflate: length matches trailer\n"));
1240 return Z_STREAM_ERROR
;
1244 Return from inflate(), updating the total counts and the check value.
1245 If there was no progress during the inflate() call, return a buffer
1246 error. Call updatewindow() to create and/or update the window state.
1247 Note: a memory error from inflate() is non-recoverable.
1251 if (state
->wsize
|| (out
!= strm
->avail_out
&& state
->mode
< BAD
&&
1252 (state
->mode
< CHECK
|| flush
!= Z_FINISH
)))
1253 if (updatewindow(strm
, strm
->next_out
, out
- strm
->avail_out
)) {
1257 in
-= strm
->avail_in
;
1258 out
-= strm
->avail_out
;
1259 strm
->total_in
+= in
;
1260 strm
->total_out
+= out
;
1261 state
->total
+= out
;
1262 if (state
->wrap
&& out
)
1263 strm
->adler
= state
->check
=
1264 UPDATE(state
->check
, strm
->next_out
- out
, out
);
1265 strm
->data_type
= state
->bits
+ (state
->last
? 64 : 0) +
1266 (state
->mode
== TYPE
? 128 : 0) +
1267 (state
->mode
== LEN_
|| state
->mode
== COPY_
? 256 : 0);
1268 if (((in
== 0 && out
== 0) || flush
== Z_FINISH
) && ret
== Z_OK
)
1273 int ZEXPORT
inflateEnd(strm
)
1276 struct inflate_state FAR
*state
;
1277 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
|| strm
->zfree
== (free_func
)0)
1278 return Z_STREAM_ERROR
;
1279 state
= (struct inflate_state FAR
*)strm
->state
;
1280 if (state
->window
!= Z_NULL
) ZFREE(strm
, state
->window
);
1281 ZFREE(strm
, strm
->state
);
1282 strm
->state
= Z_NULL
;
1283 Tracev((stderr
, "inflate: end\n"));
1287 int ZEXPORT
inflateGetDictionary(strm
, dictionary
, dictLength
)
1292 struct inflate_state FAR
*state
;
1295 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
) return Z_STREAM_ERROR
;
1296 state
= (struct inflate_state FAR
*)strm
->state
;
1298 /* copy dictionary */
1299 if (state
->whave
&& dictionary
!= Z_NULL
) {
1300 zmemcpy(dictionary
, state
->window
+ state
->wnext
,
1301 state
->whave
- state
->wnext
);
1302 zmemcpy(dictionary
+ state
->whave
- state
->wnext
,
1303 state
->window
, state
->wnext
);
1305 if (dictLength
!= Z_NULL
)
1306 *dictLength
= state
->whave
;
1310 int ZEXPORT
inflateSetDictionary(strm
, dictionary
, dictLength
)
1312 const Bytef
*dictionary
;
1315 struct inflate_state FAR
*state
;
1316 unsigned long dictid
;
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
!= 0 && state
->mode
!= DICT
)
1323 return Z_STREAM_ERROR
;
1325 /* check for correct dictionary identifier */
1326 if (state
->mode
== DICT
) {
1327 dictid
= adler32(0L, Z_NULL
, 0);
1328 dictid
= adler32(dictid
, dictionary
, dictLength
);
1329 if (dictid
!= state
->check
)
1330 return Z_DATA_ERROR
;
1333 /* copy dictionary to window using updatewindow(), which will amend the
1334 existing dictionary if appropriate */
1335 ret
= updatewindow(strm
, dictionary
+ dictLength
, dictLength
);
1340 state
->havedict
= 1;
1341 Tracev((stderr
, "inflate: dictionary set\n"));
1345 int ZEXPORT
inflateGetHeader(strm
, head
)
1349 struct inflate_state FAR
*state
;
1352 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
) return Z_STREAM_ERROR
;
1353 state
= (struct inflate_state FAR
*)strm
->state
;
1354 if ((state
->wrap
& 2) == 0) return Z_STREAM_ERROR
;
1356 /* save header structure */
1363 Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
1364 or when out of input. When called, *have is the number of pattern bytes
1365 found in order so far, in 0..3. On return *have is updated to the new
1366 state. If on return *have equals four, then the pattern was found and the
1367 return value is how many bytes were read including the last byte of the
1368 pattern. If *have is less than four, then the pattern has not been found
1369 yet and the return value is len. In the latter case, syncsearch() can be
1370 called again with more data and the *have state. *have is initialized to
1371 zero for the first call.
1373 local
unsigned syncsearch(have
, buf
, len
)
1375 const unsigned char FAR
*buf
;
1383 while (next
< len
&& got
< 4) {
1384 if ((int)(buf
[next
]) == (got
< 2 ? 0 : 0xff))
1396 int ZEXPORT
inflateSync(strm
)
1399 unsigned len
; /* number of bytes to look at or looked at */
1400 unsigned long in
, out
; /* temporary to save total_in and total_out */
1401 unsigned char buf
[4]; /* to restore bit buffer to byte string */
1402 struct inflate_state FAR
*state
;
1404 /* check parameters */
1405 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
) return Z_STREAM_ERROR
;
1406 state
= (struct inflate_state FAR
*)strm
->state
;
1407 if (strm
->avail_in
== 0 && state
->bits
< 8) return Z_BUF_ERROR
;
1409 /* if first time, start search in bit buffer */
1410 if (state
->mode
!= SYNC
) {
1412 state
->hold
<<= state
->bits
& 7;
1413 state
->bits
-= state
->bits
& 7;
1415 while (state
->bits
>= 8) {
1416 buf
[len
++] = (unsigned char)(state
->hold
);
1421 syncsearch(&(state
->have
), buf
, len
);
1424 /* search available input */
1425 len
= syncsearch(&(state
->have
), strm
->next_in
, strm
->avail_in
);
1426 strm
->avail_in
-= len
;
1427 strm
->next_in
+= len
;
1428 strm
->total_in
+= len
;
1430 /* return no joy or set up to restart inflate() on a new block */
1431 if (state
->have
!= 4) return Z_DATA_ERROR
;
1432 in
= strm
->total_in
; out
= strm
->total_out
;
1434 strm
->total_in
= in
; strm
->total_out
= out
;
1440 Returns true if inflate is currently at the end of a block generated by
1441 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
1442 implementation to provide an additional safety check. PPP uses
1443 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
1444 block. When decompressing, PPP checks that at the end of input packet,
1445 inflate is waiting for these length bytes.
1447 int ZEXPORT
inflateSyncPoint(strm
)
1450 struct inflate_state FAR
*state
;
1452 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
) return Z_STREAM_ERROR
;
1453 state
= (struct inflate_state FAR
*)strm
->state
;
1454 return state
->mode
== STORED
&& state
->bits
== 0;
1457 int ZEXPORT
inflateCopy(dest
, source
)
1461 struct inflate_state FAR
*state
;
1462 struct inflate_state FAR
*copy
;
1463 unsigned char FAR
*window
;
1467 if (dest
== Z_NULL
|| source
== Z_NULL
|| source
->state
== Z_NULL
||
1468 source
->zalloc
== (alloc_func
)0 || source
->zfree
== (free_func
)0)
1469 return Z_STREAM_ERROR
;
1470 state
= (struct inflate_state FAR
*)source
->state
;
1472 /* allocate space */
1473 copy
= (struct inflate_state FAR
*)
1474 ZALLOC(source
, 1, sizeof(struct inflate_state
));
1475 if (copy
== Z_NULL
) return Z_MEM_ERROR
;
1477 if (state
->window
!= Z_NULL
) {
1478 window
= (unsigned char FAR
*)
1479 ZALLOC(source
, 1U << state
->wbits
, sizeof(unsigned char));
1480 if (window
== Z_NULL
) {
1481 ZFREE(source
, copy
);
1487 zmemcpy((voidpf
)dest
, (voidpf
)source
, sizeof(z_stream
));
1488 zmemcpy((voidpf
)copy
, (voidpf
)state
, sizeof(struct inflate_state
));
1489 if (state
->lencode
>= state
->codes
&&
1490 state
->lencode
<= state
->codes
+ ENOUGH
- 1) {
1491 copy
->lencode
= copy
->codes
+ (state
->lencode
- state
->codes
);
1492 copy
->distcode
= copy
->codes
+ (state
->distcode
- state
->codes
);
1494 copy
->next
= copy
->codes
+ (state
->next
- state
->codes
);
1495 if (window
!= Z_NULL
) {
1496 wsize
= 1U << state
->wbits
;
1497 zmemcpy(window
, state
->window
, wsize
);
1499 copy
->window
= window
;
1500 dest
->state
= (struct internal_state FAR
*)copy
;
1504 int ZEXPORT
inflateUndermine(strm
, subvert
)
1508 struct inflate_state FAR
*state
;
1510 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
) return Z_STREAM_ERROR
;
1511 state
= (struct inflate_state FAR
*)strm
->state
;
1512 state
->sane
= !subvert
;
1513 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
1517 return Z_DATA_ERROR
;
1521 long ZEXPORT
inflateMark(strm
)
1524 struct inflate_state FAR
*state
;
1526 if (strm
== Z_NULL
|| strm
->state
== Z_NULL
) return ~0UL << 16;
1527 state
= (struct inflate_state FAR
*)strm
->state
;
1528 return ((long)(state
->back
) << 16) +
1529 (state
->mode
== COPY
? state
->length
:
1530 (state
->mode
== MATCH
? state
->was
- state
->length
: 0));