1 /* inflate.c -- zlib decompression
2 * Copyright (C) 1995-2005 Mark Adler
3 * For conditions of distribution and use, see copyright notice in zlib.h
9 * 1.2.beta0 24 Nov 2002
10 * - First version -- complete rewrite of inflate to simplify code, avoid
11 * creation of window when not needed, minimize use of window when it is
12 * needed, make inffast.c even faster, implement gzip decoding, and to
13 * improve code readability and style over the previous zlib inflate code
15 * 1.2.beta1 25 Nov 2002
16 * - Use pointers for available input and output checking in inffast.c
17 * - Remove input and output counters in inffast.c
18 * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
19 * - Remove unnecessary second byte pull from length extra in inffast.c
20 * - Unroll direct copy to three copies per loop in inffast.c
22 * 1.2.beta2 4 Dec 2002
23 * - Change external routine names to reduce potential conflicts
24 * - Correct filename to inffixed.h for fixed tables in inflate.c
25 * - Make hbuf[] unsigned char to match parameter type in inflate.c
26 * - Change strm->next_out[-state.offset] to *(strm->next_out - state.offset)
27 * to avoid negation problem on Alphas (64 bit) in inflate.c
29 * 1.2.beta3 22 Dec 2002
30 * - Add comments on state.bits assertion in inffast.c
31 * - Add comments on op field in inftrees.h
32 * - Fix bug in reuse of allocated window after inflateReset()
33 * - Remove bit fields--back to byte structure for speed
34 * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
35 * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
36 * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
37 * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
38 * - Use local copies of stream next and avail values, as well as local bit
39 * buffer and bit count in inflate()--for speed when inflate_fast() not used
41 * 1.2.beta4 1 Jan 2003
42 * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
43 * - Move a comment on output buffer sizes from inffast.c to inflate.c
44 * - Add comments in inffast.c to introduce the inflate_fast() routine
45 * - Rearrange window copies in inflate_fast() for speed and simplification
46 * - Unroll last copy for window match in inflate_fast()
47 * - Use local copies of window variables in inflate_fast() for speed
48 * - Pull out common write == 0 case for speed in inflate_fast()
49 * - Make op and len in inflate_fast() unsigned for consistency
50 * - Add FAR to lcode and dcode declarations in inflate_fast()
51 * - Simplified bad distance check in inflate_fast()
52 * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
53 * source file infback.c to provide a call-back interface to inflate for
54 * programs like gzip and unzip -- uses window as output buffer to avoid
57 * 1.2.beta5 1 Jan 2003
58 * - Improved inflateBack() interface to allow the caller to provide initial
60 * - Fixed stored blocks bug in inflateBack()
62 * 1.2.beta6 4 Jan 2003
63 * - Added comments in inffast.c on effectiveness of POSTINC
64 * - Typecasting all around to reduce compiler warnings
65 * - Changed loops from while (1) or do {} while (1) to for (;;), again to
66 * make compilers happy
67 * - Changed type of window in inflateBackInit() to unsigned char *
69 * 1.2.beta7 27 Jan 2003
70 * - Changed many types to unsigned or unsigned short to avoid warnings
71 * - Added inflateCopy() function
74 * - Changed inflateBack() interface to provide separate opaque descriptors
75 * for the in() and out() functions
76 * - Changed inflateBack() argument and in_func typedef to swap the length
77 * and buffer address return values for the input function
78 * - Check next_in and next_out for Z_NULL on entry to inflate()
80 * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
96 struct inflate_state state
;
98 /* function prototypes */
99 local
void fixedtables
OF((void));
100 local
int updatewindow
OF((z_streamp strm
, unsigned out
));
102 void makefixed
OF((void));
104 local
unsigned syncsearch
OF((unsigned FAR
*have
, unsigned char FAR
*buf
,
107 int ZEXPORT
inflateReset(strm
)
110 //struct inflate_state FAR *state;
112 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
113 //state = strm->state;
114 strm
->total_in
= strm
->total_out
= state
.total
= 0;
116 strm
->adler
= 1; /* to support ill-conceived Java test suite */
127 state
.lencode
= state
.distcode
= state
.next
= state
.codes
;
128 //DEBUGF("inflate: reset\n");
132 int ZEXPORT
inflatePrime(strm
, bits
, value
)
137 //struct inflate_state FAR *state;
139 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
140 //state = (struct inflate_state FAR *)strm->state;
141 if (bits
> 16 || state
.bits
+ bits
> 32) return Z_STREAM_ERROR
;
142 value
&= (1L << bits
) - 1;
143 state
.hold
+= value
<< state
.bits
;
148 int ZEXPORT
inflateInit2_(strm
, windowBits
, version
, stream_size
)
154 //struct inflate_state FAR *state;
156 if (version
== Z_NULL
|| version
[0] != ZLIB_VERSION
[0] ||
157 stream_size
!= (int)(sizeof(z_stream
)))
158 return Z_VERSION_ERROR
;
159 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
160 strm
->msg
= Z_NULL
; /* in case we return an error */
161 //if (strm->zalloc == (alloc_func)0) {
162 // strm->zalloc = zcalloc;
163 // strm->opaque = (voidpf)0;
165 //if (strm->zfree == (free_func)0) strm->zfree = zcfree;
166 //state = (struct inflate_state FAR *)
167 // ZALLOC(strm, 1, sizeof(struct inflate_state));
168 //if (state == Z_NULL) return Z_MEM_ERROR;
169 //DEBUGF("inflate: allocated\n");
170 //strm->state = (struct internal_state FAR *)state;
171 if (windowBits
< 0) {
173 windowBits
= -windowBits
;
176 state
.wrap
= (windowBits
>> 4) + 1;
178 if (windowBits
< 48) windowBits
&= 15;
181 if (windowBits
< 8 || windowBits
> 15) {
182 //ZFREE(strm, state);
183 //strm->state = Z_NULL;
184 return Z_STREAM_ERROR
;
186 state
.wbits
= (unsigned)windowBits
;
187 state
.window
= Z_NULL
;
188 return inflateReset(strm
);
191 int ZEXPORT
inflateInit_(strm
, version
, stream_size
)
196 return inflateInit2_(strm
, DEF_WBITS
, version
, stream_size
);
200 Return state with length and distance decoding tables and index sizes set to
201 fixed code decoding. Normally this returns fixed tables from inffixed.h.
202 If BUILDFIXED is defined, then instead this routine builds the tables the
203 first time it's called, and returns those tables the first time and
204 thereafter. This reduces the size of the code by about 2K bytes, in
205 exchange for a little execution time. However, BUILDFIXED should not be
206 used for threaded applications, since the rewriting of the tables and virgin
207 may not be thread-safe.
209 local
void fixedtables(void)
210 //struct inflate_state FAR *state;
213 static int virgin
= 1;
214 static code
*lenfix
, *distfix
;
215 static code fixed
[544];
217 /* build fixed huffman tables if first call (may not be thread safe) */
222 /* literal/length table */
224 while (sym
< 144) state
.lens
[sym
++] = 8;
225 while (sym
< 256) state
.lens
[sym
++] = 9;
226 while (sym
< 280) state
.lens
[sym
++] = 7;
227 while (sym
< 288) state
.lens
[sym
++] = 8;
231 inflate_table(LENS
, state
.lens
, 288, &(next
), &(bits
), state
.work
);
235 while (sym
< 32) state
.lens
[sym
++] = 5;
238 inflate_table(DISTS
, state
.lens
, 32, &(next
), &(bits
), state
.work
);
240 /* do this just once */
243 #else /* !BUILDFIXED */
244 # include "inffixed.h"
245 #endif /* BUILDFIXED */
246 state
.lencode
= lenfix
;
248 state
.distcode
= distfix
;
256 Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also
257 defines BUILDFIXED, so the tables are built on the fly. makefixed() writes
258 those tables to stdout, which would be piped to inffixed.h. A small program
259 can simply call makefixed to do this:
261 void makefixed(void);
269 Then that can be linked with zlib built with MAKEFIXED defined and run:
276 struct inflate_state state
;
279 puts(" /* inffixed.h -- table for decoding fixed codes");
280 puts(" * Generated automatically by makefixed().");
283 puts(" /* WARNING: this file should *not* be used by applications.");
284 puts(" It is part of the implementation of this library and is");
285 puts(" subject to change. Applications should only use zlib.h.");
289 printf(" static const code lenfix[%u] = {", size
);
292 if ((low
% 7) == 0) printf("\n ");
293 printf("{%u,%u,%d}", state
.lencode
[low
].op
, state
.lencode
[low
].bits
,
294 state
.lencode
[low
].val
);
295 if (++low
== size
) break;
300 printf("\n static const code distfix[%u] = {", size
);
303 if ((low
% 6) == 0) printf("\n ");
304 printf("{%u,%u,%d}", state
.distcode
[low
].op
, state
.distcode
[low
].bits
,
305 state
.distcode
[low
].val
);
306 if (++low
== size
) break;
311 #endif /* MAKEFIXED */
314 Update the window with the last wsize (normally 32K) bytes written before
315 returning. If window does not exist yet, create it. This is only called
316 when a window is already in use, or when output has been written during this
317 inflate call, but the end of the deflate stream has not been reached yet.
318 It is also called to create a window for dictionary data when a dictionary
321 Providing output buffers larger than 32K to inflate() should provide a speed
322 advantage, since only the last 32K of output is copied to the sliding window
323 upon return from inflate(), and since all distances after the first 32K of
324 output will fall in the output data, making match copies simpler and faster.
325 The advantage may be dependent on the size of the processor's data caches.
327 local
int updatewindow(strm
, out
)
331 //struct inflate_state FAR *state;
334 //state = (struct inflate_state FAR *)strm->state;
336 /* if it hasn't been done already, allocate space for the window */
337 if (state
.window
== Z_NULL
) {
338 state
.window
= (unsigned char FAR
*)
339 ZALLOC(strm
, 1U << state
.wbits
,
340 sizeof(unsigned char));
341 if (state
.window
== Z_NULL
) return 1;
344 /* if window not in use yet, initialize */
345 if (state
.wsize
== 0) {
346 state
.wsize
= 1U << state
.wbits
;
351 /* copy state.wsize or less output bytes into the circular window */
352 copy
= out
- strm
->avail_out
;
353 if (copy
>= state
.wsize
) {
354 zmemcpy(state
.window
, strm
->next_out
- state
.wsize
, state
.wsize
);
356 state
.whave
= state
.wsize
;
359 dist
= state
.wsize
- state
.write
;
360 if (dist
> copy
) dist
= copy
;
361 zmemcpy(state
.window
+ state
.write
, strm
->next_out
- copy
, dist
);
364 zmemcpy(state
.window
, strm
->next_out
- copy
, copy
);
366 state
.whave
= state
.wsize
;
370 if (state
.write
== state
.wsize
) state
.write
= 0;
371 if (state
.whave
< state
.wsize
) state
.whave
+= dist
;
377 /* Macros for inflate(): */
379 /* check function to use adler32() for zlib or crc32() for gzip */
381 # define UPDATE(check, buf, len) \
382 (state.flags ? crc32(check, buf, len) : adler32(check, buf, len))
384 # define UPDATE(check, buf, len) adler32(check, buf, len)
387 /* check macros for header crc */
389 # define CRC2(check, word) \
391 hbuf[0] = (unsigned char)(word); \
392 hbuf[1] = (unsigned char)((word) >> 8); \
393 check = crc32(check, hbuf, 2); \
396 # define CRC4(check, word) \
398 hbuf[0] = (unsigned char)(word); \
399 hbuf[1] = (unsigned char)((word) >> 8); \
400 hbuf[2] = (unsigned char)((word) >> 16); \
401 hbuf[3] = (unsigned char)((word) >> 24); \
402 check = crc32(check, hbuf, 4); \
406 /* Load registers with state in inflate() for speed */
409 put = strm->next_out; \
410 left = strm->avail_out; \
411 next = strm->next_in; \
412 have = strm->avail_in; \
417 /* Restore state from registers in inflate() */
420 strm->next_out = put; \
421 strm->avail_out = left; \
422 strm->next_in = next; \
423 strm->avail_in = have; \
428 /* Clear the input bit accumulator */
435 /* Get a byte of input into the bit accumulator, or return from inflate()
436 if there is no input available. */
439 if (have == 0) goto inf_leave; \
441 hold += (unsigned long)(*next++) << bits; \
445 /* Assure that there are at least n bits in the bit accumulator. If there is
446 not enough available input to do that, then return from inflate(). */
447 #define NEEDBITS(n) \
449 while (bits < (unsigned)(n)) \
453 /* Return the low n bits of the bit accumulator (n < 16) */
455 ((unsigned)hold & ((1U << (n)) - 1))
457 /* Remove n bits from the bit accumulator */
458 #define DROPBITS(n) \
461 bits -= (unsigned)(n); \
464 /* Remove zero to seven bits as needed to go to a byte boundary */
471 /* Reverse the bytes in a 32-bit value */
473 ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
474 (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
477 inflate() uses a state machine to process as much input data and generate as
478 much output data as possible before returning. The state machine is
479 structured roughly as follows:
481 for (;;) switch (state) {
484 if (not enough input data or output space to make progress)
486 ... make progress ...
492 so when inflate() is called again, the same case is attempted again, and
493 if the appropriate resources are provided, the machine proceeds to the
494 next state. The NEEDBITS() macro is usually the way the state evaluates
495 whether it can proceed or should return. NEEDBITS() does the return if
496 the requested bits are not available. The typical use of the BITS macros
500 ... do something with BITS(n) ...
503 where NEEDBITS(n) either returns from inflate() if there isn't enough
504 input left to load n bits into the accumulator, or it continues. BITS(n)
505 gives the low n bits in the accumulator. When done, DROPBITS(n) drops
506 the low n bits off the accumulator. INITBITS() clears the accumulator
507 and sets the number of available bits to zero. BYTEBITS() discards just
508 enough bits to put the accumulator on a byte boundary. After BYTEBITS()
509 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
511 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
512 if there is no input available. The decoding of variable length codes uses
513 PULLBYTE() directly in order to pull just enough bytes to decode the next
516 Some states loop until they get enough input, making sure that enough
517 state information is maintained to continue the loop where it left off
518 if NEEDBITS() returns in the loop. For example, want, need, and keep
519 would all have to actually be part of the saved state in case NEEDBITS()
523 while (want < need) {
525 keep[want++] = BITS(n);
531 As shown above, if the next state is also the next case, then the break
534 A state may also return if there is not enough output space available to
535 complete that state. Those states are copying stored data, writing a
536 literal byte, and copying a matching string.
538 When returning, a "goto inf_leave" is used to update the total counters,
539 update the check value, and determine whether any progress has been made
540 during that inflate() call in order to return the proper return code.
541 Progress is defined as a change in either strm->avail_in or strm->avail_out.
542 When there is a window, goto inf_leave will update the window with the last
543 output written. If a goto inf_leave occurs in the middle of decompression
544 and there is no window currently, goto inf_leave will create one and copy
545 output to the window for the next call of inflate().
547 In this implementation, the flush parameter of inflate() only affects the
548 return code (per zlib.h). inflate() always writes as much as possible to
549 strm->next_out, given the space available and the provided input--the effect
550 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
551 the allocation of and copying into a sliding window until necessary, which
552 provides the effect documented in zlib.h for Z_FINISH when the entire input
553 stream available. So the only thing the flush parameter actually does is:
554 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
555 will return Z_BUF_ERROR if it has not reached the end of the stream.
558 int ZEXPORT
inflate(strm
, flush
)
562 //struct inflate_state FAR *state;
563 unsigned char FAR
*next
; /* next input */
564 unsigned char FAR
*put
; /* next output */
565 unsigned have
, left
; /* available input and output */
566 unsigned long hold
; /* bit buffer */
567 unsigned bits
; /* bits in bit buffer */
568 unsigned in
, out
; /* save starting available input and output */
569 unsigned copy
; /* number of stored or match bytes to copy */
570 unsigned char FAR
*from
; /* where to copy match bytes from */
571 code
this; /* current decoding table entry */
572 code last
; /* parent table entry */
573 unsigned len
; /* length to copy for repeats, bits to drop */
574 int ret
; /* return code */
576 unsigned char hbuf
[4]; /* buffer for gzip header crc calculation */
578 static const unsigned short order
[19] = /* permutation of code lengths */
579 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
581 if (strm
== Z_NULL
|| strm
->next_out
== Z_NULL
||
582 (strm
->next_in
== Z_NULL
&& strm
->avail_in
!= 0))
583 return Z_STREAM_ERROR
;
585 uInt insize
= strm
->avail_in
;
587 //state = (struct inflate_state FAR *)strm->state;
588 if (state
.mode
== TYPE
) state
.mode
= TYPEDO
; /* skip check */
594 switch (state
.mode
) {
596 if (state
.wrap
== 0) {
602 if ((state
.wrap
& 2) && hold
== 0x8b1f) { /* gzip header */
603 state
.check
= crc32(0L, Z_NULL
, 0);
604 CRC2(state
.check
, hold
);
609 state
.flags
= 0; /* expect zlib header */
610 if (state
.head
!= Z_NULL
)
611 state
.head
->done
= -1;
612 if (!(state
.wrap
& 1) || /* check if zlib header allowed */
616 ((BITS(8) << 8) + (hold
>> 8)) % 31) {
617 strm
->msg
= (char *)"incorrect header check";
621 if (BITS(4) != Z_DEFLATED
) {
622 strm
->msg
= (char *)"unknown compression method";
628 if (len
> state
.wbits
) {
629 strm
->msg
= (char *)"invalid window size";
633 state
.dmax
= 1U << len
;
634 //DEBUGF("inflate: zlib header ok\n");
635 strm
->adler
= state
.check
= adler32(0L, Z_NULL
, 0);
636 state
.mode
= hold
& 0x200 ? DICTID
: TYPE
;
642 state
.flags
= (int)(hold
);
643 if ((state
.flags
& 0xff) != Z_DEFLATED
) {
644 strm
->msg
= (char *)"unknown compression method";
648 if (state
.flags
& 0xe000) {
649 strm
->msg
= (char *)"unknown header flags set";
653 if (state
.head
!= Z_NULL
)
654 state
.head
->text
= (int)((hold
>> 8) & 1);
655 if (state
.flags
& 0x0200) CRC2(state
.check
, hold
);
660 if (state
.head
!= Z_NULL
)
661 state
.head
->time
= hold
;
662 if (state
.flags
& 0x0200) CRC4(state
.check
, hold
);
667 if (state
.head
!= Z_NULL
) {
668 state
.head
->xflags
= (int)(hold
& 0xff);
669 state
.head
->os
= (int)(hold
>> 8);
671 if (state
.flags
& 0x0200) CRC2(state
.check
, hold
);
675 if (state
.flags
& 0x0400) {
677 state
.length
= (unsigned)(hold
);
678 if (state
.head
!= Z_NULL
)
679 state
.head
->extra_len
= (unsigned)hold
;
680 if (state
.flags
& 0x0200) CRC2(state
.check
, hold
);
683 else if (state
.head
!= Z_NULL
)
684 state
.head
->extra
= Z_NULL
;
687 if (state
.flags
& 0x0400) {
689 if (copy
> have
) copy
= have
;
691 if (state
.head
!= Z_NULL
&&
692 state
.head
->extra
!= Z_NULL
) {
693 len
= state
.head
->extra_len
- state
.length
;
694 zmemcpy(state
.head
->extra
+ len
, next
,
695 len
+ copy
> state
.head
->extra_max
?
696 state
.head
->extra_max
- len
: copy
);
698 if (state
.flags
& 0x0200)
699 state
.check
= crc32(state
.check
, next
, copy
);
702 state
.length
-= copy
;
704 if (state
.length
) goto inf_leave
;
709 if (state
.flags
& 0x0800) {
710 if (have
== 0) goto inf_leave
;
713 len
= (unsigned)(next
[copy
++]);
714 if (state
.head
!= Z_NULL
&&
715 state
.head
->name
!= Z_NULL
&&
716 state
.length
< state
.head
->name_max
)
717 state
.head
->name
[state
.length
++] = len
;
718 } while (len
&& copy
< have
);
719 if (state
.flags
& 0x0200)
720 state
.check
= crc32(state
.check
, next
, copy
);
723 if (len
) goto inf_leave
;
725 else if (state
.head
!= Z_NULL
)
726 state
.head
->name
= Z_NULL
;
728 state
.mode
= COMMENT
;
730 if (state
.flags
& 0x1000) {
731 if (have
== 0) goto inf_leave
;
734 len
= (unsigned)(next
[copy
++]);
735 if (state
.head
!= Z_NULL
&&
736 state
.head
->comment
!= Z_NULL
&&
737 state
.length
< state
.head
->comm_max
)
738 state
.head
->comment
[state
.length
++] = len
;
739 } while (len
&& copy
< have
);
740 if (state
.flags
& 0x0200)
741 state
.check
= crc32(state
.check
, next
, copy
);
744 if (len
) goto inf_leave
;
746 else if (state
.head
!= Z_NULL
)
747 state
.head
->comment
= Z_NULL
;
750 if (state
.flags
& 0x0200) {
752 if (hold
!= (state
.check
& 0xffff)) {
753 strm
->msg
= (char *)"header crc mismatch";
759 if (state
.head
!= Z_NULL
) {
760 state
.head
->hcrc
= (int)((state
.flags
>> 9) & 1);
761 state
.head
->done
= 1;
763 strm
->adler
= state
.check
= crc32(0L, Z_NULL
, 0);
769 strm
->adler
= state
.check
= REVERSE(hold
);
773 if (state
.havedict
== 0) {
777 strm
->adler
= state
.check
= adler32(0L, Z_NULL
, 0);
780 if (flush
== Z_BLOCK
) goto inf_leave
;
788 state
.last
= BITS(1);
791 case 0: /* stored block */
792 //DEBUGF("inflate: stored block%s\n",
793 //state.last ? " (last)" : "");
796 case 1: /* fixed block */
798 //DEBUGF("inflate: fixed codes block%s\n",
799 //state.last ? " (last)" : "");
800 state
.mode
= LEN
; /* decode codes */
802 case 2: /* dynamic block */
803 //DEBUGF("inflate: dynamic codes block%s\n",
804 //state.last ? " (last)" : "");
808 strm
->msg
= (char *)"invalid block type";
814 BYTEBITS(); /* go to byte boundary */
816 if ((hold
& 0xffff) != ((hold
>> 16) ^ 0xffff)) {
817 strm
->msg
= (char *)"invalid stored block lengths";
821 state
.length
= (unsigned)hold
& 0xffff;
822 //DEBUGF("inflate: stored length %u\n",
829 if (copy
> have
) copy
= have
;
830 if (copy
> left
) copy
= left
;
831 if (copy
== 0) goto inf_leave
;
832 zmemcpy(put
, next
, copy
);
837 state
.length
-= copy
;
840 //DEBUGF("inflate: stored end\n");
845 state
.nlen
= BITS(5) + 257;
847 state
.ndist
= BITS(5) + 1;
849 state
.ncode
= BITS(4) + 4;
851 #ifndef PKZIP_BUG_WORKAROUND
852 if (state
.nlen
> 286 || state
.ndist
> 30) {
853 strm
->msg
= (char *)"too many length or distance symbols";
858 //DEBUGF("inflate: table sizes ok\n");
860 state
.mode
= LENLENS
;
862 while (state
.have
< state
.ncode
) {
864 state
.lens
[order
[state
.have
++]] = (unsigned short)BITS(3);
867 while (state
.have
< 19)
868 state
.lens
[order
[state
.have
++]] = 0;
869 state
.next
= state
.codes
;
870 state
.lencode
= (code
const FAR
*)(state
.next
);
872 ret
= inflate_table(CODES
, state
.lens
, 19, &(state
.next
),
873 &(state
.lenbits
), state
.work
);
875 strm
->msg
= (char *)"invalid code lengths set";
879 //DEBUGF("inflate: code lengths ok\n");
881 state
.mode
= CODELENS
;
883 while (state
.have
< state
.nlen
+ state
.ndist
) {
885 this = state
.lencode
[BITS(state
.lenbits
)];
886 if ((unsigned)(this.bits
) <= bits
) break;
892 state
.lens
[state
.have
++] = this.val
;
895 if (this.val
== 16) {
896 NEEDBITS(this.bits
+ 2);
898 if (state
.have
== 0) {
899 strm
->msg
= (char *)"invalid bit length repeat";
903 len
= state
.lens
[state
.have
- 1];
907 else if (this.val
== 17) {
908 NEEDBITS(this.bits
+ 3);
915 NEEDBITS(this.bits
+ 7);
921 if (state
.have
+ copy
> state
.nlen
+ state
.ndist
) {
922 strm
->msg
= (char *)"invalid bit length repeat";
927 state
.lens
[state
.have
++] = (unsigned short)len
;
931 /* handle error breaks in while */
932 if (state
.mode
== BAD
) break;
934 /* build code tables */
935 state
.next
= state
.codes
;
936 state
.lencode
= (code
const FAR
*)(state
.next
);
938 ret
= inflate_table(LENS
, state
.lens
, state
.nlen
, &(state
.next
),
939 &(state
.lenbits
), state
.work
);
941 strm
->msg
= (char *)"invalid literal/lengths set";
945 state
.distcode
= (code
const FAR
*)(state
.next
);
947 ret
= inflate_table(DISTS
, state
.lens
+ state
.nlen
, state
.ndist
,
948 &(state
.next
), &(state
.distbits
), state
.work
);
950 strm
->msg
= (char *)"invalid distances set";
954 //DEBUGF("inflate: codes ok\n");
957 if (have
>= 6 && left
>= 258) {
959 inflate_fast(strm
, out
);
964 this = state
.lencode
[BITS(state
.lenbits
)];
965 if ((unsigned)(this.bits
) <= bits
) break;
968 if (this.op
&& (this.op
& 0xf0) == 0) {
971 this = state
.lencode
[last
.val
+
972 (BITS(last
.bits
+ last
.op
) >> last
.bits
)];
973 if ((unsigned)(last
.bits
+ this.bits
) <= bits
) break;
979 state
.length
= (unsigned)this.val
;
980 if ((int)(this.op
) == 0) {
981 //DEBUGF(this.val >= 0x20 && this.val < 0x7f ?
982 //"inflate: literal '%c'\n" :
983 //"inflate: literal 0x%02x\n", this.val);
988 //DEBUGF("inflate: end of block\n");
993 strm
->msg
= (char *)"invalid literal/length code";
997 state
.extra
= (unsigned)(this.op
) & 15;
1001 NEEDBITS(state
.extra
);
1002 state
.length
+= BITS(state
.extra
);
1003 DROPBITS(state
.extra
);
1005 //DEBUGF("inflate: length %u\n", state.length);
1009 this = state
.distcode
[BITS(state
.distbits
)];
1010 if ((unsigned)(this.bits
) <= bits
) break;
1013 if ((this.op
& 0xf0) == 0) {
1016 this = state
.distcode
[last
.val
+
1017 (BITS(last
.bits
+ last
.op
) >> last
.bits
)];
1018 if ((unsigned)(last
.bits
+ this.bits
) <= bits
) break;
1021 DROPBITS(last
.bits
);
1023 DROPBITS(this.bits
);
1025 strm
->msg
= (char *)"invalid distance code";
1029 state
.offset
= (unsigned)this.val
;
1030 state
.extra
= (unsigned)(this.op
) & 15;
1031 state
.mode
= DISTEXT
;
1034 NEEDBITS(state
.extra
);
1035 state
.offset
+= BITS(state
.extra
);
1036 DROPBITS(state
.extra
);
1038 #ifdef INFLATE_STRICT
1039 if (state
.offset
> state
.dmax
) {
1040 strm
->msg
= (char *)"invalid distance too far back";
1045 if (state
.offset
> state
.whave
+ out
- left
) {
1046 strm
->msg
= (char *)"invalid distance too far back";
1050 //DEBUGF("inflate: distance %u\n", state.offset);
1053 if (left
== 0) goto inf_leave
;
1055 if (state
.offset
> copy
) { /* copy from window */
1056 copy
= state
.offset
- copy
;
1057 if (copy
> state
.write
) {
1058 copy
-= state
.write
;
1059 from
= state
.window
+ (state
.wsize
- copy
);
1062 from
= state
.window
+ (state
.write
- copy
);
1063 if (copy
> state
.length
) copy
= state
.length
;
1065 else { /* copy from output */
1066 from
= put
- state
.offset
;
1067 copy
= state
.length
;
1069 if (copy
> left
) copy
= left
;
1071 state
.length
-= copy
;
1075 if (state
.length
== 0) state
.mode
= LEN
;
1078 if (left
== 0) goto inf_leave
;
1079 *put
++ = (unsigned char)(state
.length
);
1087 strm
->total_out
+= out
;
1090 strm
->adler
= state
.check
=
1091 UPDATE(state
.check
, put
- out
, out
);
1095 state
.flags
? hold
:
1097 REVERSE(hold
)) != state
.check
) {
1098 strm
->msg
= (char *)"incorrect data check";
1103 //DEBUGF("inflate: check matches trailer\n");
1106 state
.mode
= LENGTH
;
1108 if (state
.wrap
&& state
.flags
) {
1110 if (hold
!= (state
.total
& 0xffffffffUL
)) {
1111 strm
->msg
= (char *)"incorrect length check";
1116 Tracev((stderr
, "inflate: length matches trailer\n"));
1130 return Z_STREAM_ERROR
;
1132 //DEBUGF("%d / %d\n", strm->total_in, strm->avail_in);
1133 if (rb
->button_get(false) == IMGVIEW_MENU
)
1134 return PLUGIN_ABORT
;
1135 else cb_progress(insize
- strm
->avail_in
, insize
);
1139 Return from inflate(), updating the total counts and the check value.
1140 If there was no progress during the inflate() call, return a buffer
1141 error. Call updatewindow() to create and/or update the window state.
1142 Note: a memory error from inflate() is non-recoverable.
1146 if (state
.wsize
|| (state
.mode
< CHECK
&& out
!= strm
->avail_out
))
1147 if (updatewindow(strm
, out
)) {
1151 in
-= strm
->avail_in
;
1152 out
-= strm
->avail_out
;
1153 strm
->total_in
+= in
;
1154 strm
->total_out
+= out
;
1156 if (state
.wrap
&& out
)
1157 strm
->adler
= state
.check
=
1158 UPDATE(state
.check
, strm
->next_out
- out
, out
);
1159 strm
->data_type
= state
.bits
+ (state
.last
? 64 : 0) +
1160 (state
.mode
== TYPE
? 128 : 0);
1161 if (((in
== 0 && out
== 0) || flush
== Z_FINISH
) && ret
== Z_OK
)
1166 int ZEXPORT
inflateEnd(strm
)
1169 //struct inflate_state FAR *state;
1170 if (strm
== Z_NULL
/*|| strm->zfree == (free_func)0*/)
1171 return Z_STREAM_ERROR
;
1172 //state = (struct inflate_state FAR *)strm->state;
1173 //if (state.window != Z_NULL) ZFREE(strm, state.window);
1174 //ZFREE(strm, strm->state);
1175 //strm->state = Z_NULL;
1176 //DEBUGF("inflate: end\n");
1180 int ZEXPORT
inflateSetDictionary(strm
, dictionary
, dictLength
)
1182 const Bytef
*dictionary
;
1185 //struct inflate_state FAR *state;
1189 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
1190 //state = (struct inflate_state FAR *)strm->state;
1191 if (state
.wrap
!= 0 && state
.mode
!= DICT
)
1192 return Z_STREAM_ERROR
;
1194 /* check for correct dictionary id */
1195 if (state
.mode
== DICT
) {
1196 id
= adler32(0L, Z_NULL
, 0);
1197 id
= adler32(id
, dictionary
, dictLength
);
1198 if (id
!= state
.check
)
1199 return Z_DATA_ERROR
;
1202 /* copy dictionary to window */
1203 if (updatewindow(strm
, strm
->avail_out
)) {
1207 if (dictLength
> state
.wsize
) {
1208 zmemcpy(state
.window
, dictionary
+ dictLength
- state
.wsize
,
1210 state
.whave
= state
.wsize
;
1213 zmemcpy(state
.window
+ state
.wsize
- dictLength
, dictionary
,
1215 state
.whave
= dictLength
;
1218 //DEBUGF("inflate: dictionary set\n");
1222 int ZEXPORT
inflateGetHeader(strm
, head
)
1226 //struct inflate_state FAR *state;
1229 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
1230 //state = (struct inflate_state FAR *)strm->state;
1231 if ((state
.wrap
& 2) == 0) return Z_STREAM_ERROR
;
1233 /* save header structure */
1240 Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
1241 or when out of input. When called, *have is the number of pattern bytes
1242 found in order so far, in 0..3. On return *have is updated to the new
1243 state. If on return *have equals four, then the pattern was found and the
1244 return value is how many bytes were read including the last byte of the
1245 pattern. If *have is less than four, then the pattern has not been found
1246 yet and the return value is len. In the latter case, syncsearch() can be
1247 called again with more data and the *have state. *have is initialized to
1248 zero for the first call.
1250 local
unsigned syncsearch(have
, buf
, len
)
1252 unsigned char FAR
*buf
;
1260 while (next
< len
&& got
< 4) {
1261 if ((int)(buf
[next
]) == (got
< 2 ? 0 : 0xff))
1273 int ZEXPORT
inflateSync(strm
)
1276 unsigned len
; /* number of bytes to look at or looked at */
1277 unsigned long in
, out
; /* temporary to save total_in and total_out */
1278 unsigned char buf
[4]; /* to restore bit buffer to byte string */
1279 //struct inflate_state FAR *state;
1281 /* check parameters */
1282 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
1283 //state = (struct inflate_state FAR *)strm->state;
1284 if (strm
->avail_in
== 0 && state
.bits
< 8) return Z_BUF_ERROR
;
1286 /* if first time, start search in bit buffer */
1287 if (state
.mode
!= SYNC
) {
1289 state
.hold
<<= state
.bits
& 7;
1290 state
.bits
-= state
.bits
& 7;
1292 while (state
.bits
>= 8) {
1293 buf
[len
++] = (unsigned char)(state
.hold
);
1298 syncsearch(&(state
.have
), buf
, len
);
1301 /* search available input */
1302 len
= syncsearch(&(state
.have
), strm
->next_in
, strm
->avail_in
);
1303 strm
->avail_in
-= len
;
1304 strm
->next_in
+= len
;
1305 strm
->total_in
+= len
;
1307 /* return no joy or set up to restart inflate() on a new block */
1308 if (state
.have
!= 4) return Z_DATA_ERROR
;
1309 in
= strm
->total_in
; out
= strm
->total_out
;
1311 strm
->total_in
= in
; strm
->total_out
= out
;
1317 Returns true if inflate is currently at the end of a block generated by
1318 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
1319 implementation to provide an additional safety check. PPP uses
1320 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
1321 block. When decompressing, PPP checks that at the end of input packet,
1322 inflate is waiting for these length bytes.
1324 int ZEXPORT
inflateSyncPoint(strm
)
1327 //struct inflate_state FAR *state;
1329 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
1330 //state = (struct inflate_state FAR *)strm->state;
1331 return state
.mode
== STORED
&& state
.bits
== 0;