]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - lib/zlib_inflate/inflate.c
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
5 * Based on zlib 1.2.3 but modified for the Linux Kernel by
6 * Richard Purdie <richard@openedhand.com>
8 * Changes mainly for static instead of dynamic memory allocation
12 #include <linux/zutil.h>
18 int zlib_inflate_workspacesize(void)
20 return sizeof(struct inflate_workspace
);
23 int zlib_inflateReset(z_streamp strm
)
25 struct inflate_state
*state
;
27 if (strm
== NULL
|| strm
->state
== NULL
) return Z_STREAM_ERROR
;
28 state
= (struct inflate_state
*)strm
->state
;
29 strm
->total_in
= strm
->total_out
= state
->total
= 0;
31 strm
->adler
= 1; /* to support ill-conceived Java test suite */
38 state
->lencode
= state
->distcode
= state
->next
= state
->codes
;
40 /* Initialise Window */
41 state
->wsize
= 1U << state
->wbits
;
49 int zlib_inflatePrime(z_streamp strm
, int bits
, int value
)
51 struct inflate_state
*state
;
53 if (strm
== NULL
|| strm
->state
== NULL
) return Z_STREAM_ERROR
;
54 state
= (struct inflate_state
*)strm
->state
;
55 if (bits
> 16 || state
->bits
+ bits
> 32) return Z_STREAM_ERROR
;
56 value
&= (1L << bits
) - 1;
57 state
->hold
+= value
<< state
->bits
;
63 int zlib_inflateInit2(z_streamp strm
, int windowBits
)
65 struct inflate_state
*state
;
67 if (strm
== NULL
) return Z_STREAM_ERROR
;
68 strm
->msg
= NULL
; /* in case we return an error */
70 state
= &WS(strm
)->inflate_state
;
71 strm
->state
= (struct internal_state
*)state
;
75 windowBits
= -windowBits
;
78 state
->wrap
= (windowBits
>> 4) + 1;
80 if (windowBits
< 8 || windowBits
> 15) {
81 return Z_STREAM_ERROR
;
83 state
->wbits
= (unsigned)windowBits
;
84 state
->window
= &WS(strm
)->working_window
[0];
86 return zlib_inflateReset(strm
);
90 Return state with length and distance decoding tables and index sizes set to
91 fixed code decoding. This returns fixed tables from inffixed.h.
93 static void zlib_fixedtables(struct inflate_state
*state
)
95 # include "inffixed.h"
96 state
->lencode
= lenfix
;
98 state
->distcode
= distfix
;
104 Update the window with the last wsize (normally 32K) bytes written before
105 returning. This is only called when a window is already in use, or when
106 output has been written during this inflate call, but the end of the deflate
107 stream has not been reached yet. It is also called to window dictionary data
108 when a dictionary is loaded.
110 Providing output buffers larger than 32K to inflate() should provide a speed
111 advantage, since only the last 32K of output is copied to the sliding window
112 upon return from inflate(), and since all distances after the first 32K of
113 output will fall in the output data, making match copies simpler and faster.
114 The advantage may be dependent on the size of the processor's data caches.
116 static void zlib_updatewindow(z_streamp strm
, unsigned out
)
118 struct inflate_state
*state
;
121 state
= (struct inflate_state
*)strm
->state
;
123 /* copy state->wsize or less output bytes into the circular window */
124 copy
= out
- strm
->avail_out
;
125 if (copy
>= state
->wsize
) {
126 memcpy(state
->window
, strm
->next_out
- state
->wsize
, state
->wsize
);
128 state
->whave
= state
->wsize
;
131 dist
= state
->wsize
- state
->write
;
132 if (dist
> copy
) dist
= copy
;
133 memcpy(state
->window
+ state
->write
, strm
->next_out
- copy
, dist
);
136 memcpy(state
->window
, strm
->next_out
- copy
, copy
);
138 state
->whave
= state
->wsize
;
141 state
->write
+= dist
;
142 if (state
->write
== state
->wsize
) state
->write
= 0;
143 if (state
->whave
< state
->wsize
) state
->whave
+= dist
;
150 * At the end of a Deflate-compressed PPP packet, we expect to have seen
151 * a `stored' block type value but not the (zero) length bytes.
154 Returns true if inflate is currently at the end of a block generated by
155 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
156 implementation to provide an additional safety check. PPP uses
157 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
158 block. When decompressing, PPP checks that at the end of input packet,
159 inflate is waiting for these length bytes.
161 static int zlib_inflateSyncPacket(z_streamp strm
)
163 struct inflate_state
*state
;
165 if (strm
== NULL
|| strm
->state
== NULL
) return Z_STREAM_ERROR
;
166 state
= (struct inflate_state
*)strm
->state
;
168 if (state
->mode
== STORED
&& state
->bits
== 0) {
175 /* Macros for inflate(): */
177 /* check function to use adler32() for zlib or crc32() for gzip */
178 #define UPDATE(check, buf, len) zlib_adler32(check, buf, len)
180 /* Load registers with state in inflate() for speed */
183 put = strm->next_out; \
184 left = strm->avail_out; \
185 next = strm->next_in; \
186 have = strm->avail_in; \
187 hold = state->hold; \
188 bits = state->bits; \
191 /* Restore state from registers in inflate() */
194 strm->next_out = put; \
195 strm->avail_out = left; \
196 strm->next_in = next; \
197 strm->avail_in = have; \
198 state->hold = hold; \
199 state->bits = bits; \
202 /* Clear the input bit accumulator */
209 /* Get a byte of input into the bit accumulator, or return from inflate()
210 if there is no input available. */
213 if (have == 0) goto inf_leave; \
215 hold += (unsigned long)(*next++) << bits; \
219 /* Assure that there are at least n bits in the bit accumulator. If there is
220 not enough available input to do that, then return from inflate(). */
221 #define NEEDBITS(n) \
223 while (bits < (unsigned)(n)) \
227 /* Return the low n bits of the bit accumulator (n < 16) */
229 ((unsigned)hold & ((1U << (n)) - 1))
231 /* Remove n bits from the bit accumulator */
232 #define DROPBITS(n) \
235 bits -= (unsigned)(n); \
238 /* Remove zero to seven bits as needed to go to a byte boundary */
245 /* Reverse the bytes in a 32-bit value */
247 ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
248 (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
251 inflate() uses a state machine to process as much input data and generate as
252 much output data as possible before returning. The state machine is
253 structured roughly as follows:
255 for (;;) switch (state) {
258 if (not enough input data or output space to make progress)
260 ... make progress ...
266 so when inflate() is called again, the same case is attempted again, and
267 if the appropriate resources are provided, the machine proceeds to the
268 next state. The NEEDBITS() macro is usually the way the state evaluates
269 whether it can proceed or should return. NEEDBITS() does the return if
270 the requested bits are not available. The typical use of the BITS macros
274 ... do something with BITS(n) ...
277 where NEEDBITS(n) either returns from inflate() if there isn't enough
278 input left to load n bits into the accumulator, or it continues. BITS(n)
279 gives the low n bits in the accumulator. When done, DROPBITS(n) drops
280 the low n bits off the accumulator. INITBITS() clears the accumulator
281 and sets the number of available bits to zero. BYTEBITS() discards just
282 enough bits to put the accumulator on a byte boundary. After BYTEBITS()
283 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
285 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
286 if there is no input available. The decoding of variable length codes uses
287 PULLBYTE() directly in order to pull just enough bytes to decode the next
290 Some states loop until they get enough input, making sure that enough
291 state information is maintained to continue the loop where it left off
292 if NEEDBITS() returns in the loop. For example, want, need, and keep
293 would all have to actually be part of the saved state in case NEEDBITS()
297 while (want < need) {
299 keep[want++] = BITS(n);
305 As shown above, if the next state is also the next case, then the break
308 A state may also return if there is not enough output space available to
309 complete that state. Those states are copying stored data, writing a
310 literal byte, and copying a matching string.
312 When returning, a "goto inf_leave" is used to update the total counters,
313 update the check value, and determine whether any progress has been made
314 during that inflate() call in order to return the proper return code.
315 Progress is defined as a change in either strm->avail_in or strm->avail_out.
316 When there is a window, goto inf_leave will update the window with the last
317 output written. If a goto inf_leave occurs in the middle of decompression
318 and there is no window currently, goto inf_leave will create one and copy
319 output to the window for the next call of inflate().
321 In this implementation, the flush parameter of inflate() only affects the
322 return code (per zlib.h). inflate() always writes as much as possible to
323 strm->next_out, given the space available and the provided input--the effect
324 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
325 the allocation of and copying into a sliding window until necessary, which
326 provides the effect documented in zlib.h for Z_FINISH when the entire input
327 stream available. So the only thing the flush parameter actually does is:
328 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
329 will return Z_BUF_ERROR if it has not reached the end of the stream.
332 int zlib_inflate(z_streamp strm
, int flush
)
334 struct inflate_state
*state
;
335 unsigned char *next
; /* next input */
336 unsigned char *put
; /* next output */
337 unsigned have
, left
; /* available input and output */
338 unsigned long hold
; /* bit buffer */
339 unsigned bits
; /* bits in bit buffer */
340 unsigned in
, out
; /* save starting available input and output */
341 unsigned copy
; /* number of stored or match bytes to copy */
342 unsigned char *from
; /* where to copy match bytes from */
343 code
this; /* current decoding table entry */
344 code last
; /* parent table entry */
345 unsigned len
; /* length to copy for repeats, bits to drop */
346 int ret
; /* return code */
347 static const unsigned short order
[19] = /* permutation of code lengths */
348 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
350 if (strm
== NULL
|| strm
->state
== NULL
|| strm
->next_out
== NULL
||
351 (strm
->next_in
== NULL
&& strm
->avail_in
!= 0))
352 return Z_STREAM_ERROR
;
354 state
= (struct inflate_state
*)strm
->state
;
356 if (state
->mode
== TYPE
) state
->mode
= TYPEDO
; /* skip check */
362 switch (state
->mode
) {
364 if (state
->wrap
== 0) {
365 state
->mode
= TYPEDO
;
370 ((BITS(8) << 8) + (hold
>> 8)) % 31) {
371 strm
->msg
= (char *)"incorrect header check";
375 if (BITS(4) != Z_DEFLATED
) {
376 strm
->msg
= (char *)"unknown compression method";
382 if (len
> state
->wbits
) {
383 strm
->msg
= (char *)"invalid window size";
387 state
->dmax
= 1U << len
;
388 strm
->adler
= state
->check
= zlib_adler32(0L, NULL
, 0);
389 state
->mode
= hold
& 0x200 ? DICTID
: TYPE
;
394 strm
->adler
= state
->check
= REVERSE(hold
);
398 if (state
->havedict
== 0) {
402 strm
->adler
= state
->check
= zlib_adler32(0L, NULL
, 0);
405 if (flush
== Z_BLOCK
) goto inf_leave
;
413 state
->last
= BITS(1);
416 case 0: /* stored block */
417 state
->mode
= STORED
;
419 case 1: /* fixed block */
420 zlib_fixedtables(state
);
421 state
->mode
= LEN
; /* decode codes */
423 case 2: /* dynamic block */
427 strm
->msg
= (char *)"invalid block type";
433 BYTEBITS(); /* go to byte boundary */
435 if ((hold
& 0xffff) != ((hold
>> 16) ^ 0xffff)) {
436 strm
->msg
= (char *)"invalid stored block lengths";
440 state
->length
= (unsigned)hold
& 0xffff;
444 copy
= state
->length
;
446 if (copy
> have
) copy
= have
;
447 if (copy
> left
) copy
= left
;
448 if (copy
== 0) goto inf_leave
;
449 memcpy(put
, next
, copy
);
454 state
->length
-= copy
;
461 state
->nlen
= BITS(5) + 257;
463 state
->ndist
= BITS(5) + 1;
465 state
->ncode
= BITS(4) + 4;
467 #ifndef PKZIP_BUG_WORKAROUND
468 if (state
->nlen
> 286 || state
->ndist
> 30) {
469 strm
->msg
= (char *)"too many length or distance symbols";
475 state
->mode
= LENLENS
;
477 while (state
->have
< state
->ncode
) {
479 state
->lens
[order
[state
->have
++]] = (unsigned short)BITS(3);
482 while (state
->have
< 19)
483 state
->lens
[order
[state
->have
++]] = 0;
484 state
->next
= state
->codes
;
485 state
->lencode
= (code
const *)(state
->next
);
487 ret
= zlib_inflate_table(CODES
, state
->lens
, 19, &(state
->next
),
488 &(state
->lenbits
), state
->work
);
490 strm
->msg
= (char *)"invalid code lengths set";
495 state
->mode
= CODELENS
;
497 while (state
->have
< state
->nlen
+ state
->ndist
) {
499 this = state
->lencode
[BITS(state
->lenbits
)];
500 if ((unsigned)(this.bits
) <= bits
) break;
506 state
->lens
[state
->have
++] = this.val
;
509 if (this.val
== 16) {
510 NEEDBITS(this.bits
+ 2);
512 if (state
->have
== 0) {
513 strm
->msg
= (char *)"invalid bit length repeat";
517 len
= state
->lens
[state
->have
- 1];
521 else if (this.val
== 17) {
522 NEEDBITS(this.bits
+ 3);
529 NEEDBITS(this.bits
+ 7);
535 if (state
->have
+ copy
> state
->nlen
+ state
->ndist
) {
536 strm
->msg
= (char *)"invalid bit length repeat";
541 state
->lens
[state
->have
++] = (unsigned short)len
;
545 /* handle error breaks in while */
546 if (state
->mode
== BAD
) break;
548 /* build code tables */
549 state
->next
= state
->codes
;
550 state
->lencode
= (code
const *)(state
->next
);
552 ret
= zlib_inflate_table(LENS
, state
->lens
, state
->nlen
, &(state
->next
),
553 &(state
->lenbits
), state
->work
);
555 strm
->msg
= (char *)"invalid literal/lengths set";
559 state
->distcode
= (code
const *)(state
->next
);
561 ret
= zlib_inflate_table(DISTS
, state
->lens
+ state
->nlen
, state
->ndist
,
562 &(state
->next
), &(state
->distbits
), state
->work
);
564 strm
->msg
= (char *)"invalid distances set";
570 if (have
>= 6 && left
>= 258) {
572 inflate_fast(strm
, out
);
577 this = state
->lencode
[BITS(state
->lenbits
)];
578 if ((unsigned)(this.bits
) <= bits
) break;
581 if (this.op
&& (this.op
& 0xf0) == 0) {
584 this = state
->lencode
[last
.val
+
585 (BITS(last
.bits
+ last
.op
) >> last
.bits
)];
586 if ((unsigned)(last
.bits
+ this.bits
) <= bits
) break;
592 state
->length
= (unsigned)this.val
;
593 if ((int)(this.op
) == 0) {
602 strm
->msg
= (char *)"invalid literal/length code";
606 state
->extra
= (unsigned)(this.op
) & 15;
607 state
->mode
= LENEXT
;
610 NEEDBITS(state
->extra
);
611 state
->length
+= BITS(state
->extra
);
612 DROPBITS(state
->extra
);
617 this = state
->distcode
[BITS(state
->distbits
)];
618 if ((unsigned)(this.bits
) <= bits
) break;
621 if ((this.op
& 0xf0) == 0) {
624 this = state
->distcode
[last
.val
+
625 (BITS(last
.bits
+ last
.op
) >> last
.bits
)];
626 if ((unsigned)(last
.bits
+ this.bits
) <= bits
) break;
633 strm
->msg
= (char *)"invalid distance code";
637 state
->offset
= (unsigned)this.val
;
638 state
->extra
= (unsigned)(this.op
) & 15;
639 state
->mode
= DISTEXT
;
642 NEEDBITS(state
->extra
);
643 state
->offset
+= BITS(state
->extra
);
644 DROPBITS(state
->extra
);
646 #ifdef INFLATE_STRICT
647 if (state
->offset
> state
->dmax
) {
648 strm
->msg
= (char *)"invalid distance too far back";
653 if (state
->offset
> state
->whave
+ out
- left
) {
654 strm
->msg
= (char *)"invalid distance too far back";
660 if (left
== 0) goto inf_leave
;
662 if (state
->offset
> copy
) { /* copy from window */
663 copy
= state
->offset
- copy
;
664 if (copy
> state
->write
) {
665 copy
-= state
->write
;
666 from
= state
->window
+ (state
->wsize
- copy
);
669 from
= state
->window
+ (state
->write
- copy
);
670 if (copy
> state
->length
) copy
= state
->length
;
672 else { /* copy from output */
673 from
= put
- state
->offset
;
674 copy
= state
->length
;
676 if (copy
> left
) copy
= left
;
678 state
->length
-= copy
;
682 if (state
->length
== 0) state
->mode
= LEN
;
685 if (left
== 0) goto inf_leave
;
686 *put
++ = (unsigned char)(state
->length
);
694 strm
->total_out
+= out
;
697 strm
->adler
= state
->check
=
698 UPDATE(state
->check
, put
- out
, out
);
701 REVERSE(hold
)) != state
->check
) {
702 strm
->msg
= (char *)"incorrect data check";
719 return Z_STREAM_ERROR
;
723 Return from inflate(), updating the total counts and the check value.
724 If there was no progress during the inflate() call, return a buffer
725 error. Call zlib_updatewindow() to create and/or update the window state.
729 if (state
->wsize
|| (state
->mode
< CHECK
&& out
!= strm
->avail_out
))
730 zlib_updatewindow(strm
, out
);
732 in
-= strm
->avail_in
;
733 out
-= strm
->avail_out
;
734 strm
->total_in
+= in
;
735 strm
->total_out
+= out
;
737 if (state
->wrap
&& out
)
738 strm
->adler
= state
->check
=
739 UPDATE(state
->check
, strm
->next_out
- out
, out
);
741 strm
->data_type
= state
->bits
+ (state
->last
? 64 : 0) +
742 (state
->mode
== TYPE
? 128 : 0);
743 if (((in
== 0 && out
== 0) || flush
== Z_FINISH
) && ret
== Z_OK
)
746 if (flush
== Z_PACKET_FLUSH
&& ret
== Z_OK
&&
747 (strm
->avail_out
!= 0 || strm
->avail_in
== 0))
748 return zlib_inflateSyncPacket(strm
);
752 int zlib_inflateEnd(z_streamp strm
)
754 if (strm
== NULL
|| strm
->state
== NULL
)
755 return Z_STREAM_ERROR
;
760 int zlib_inflateSetDictionary(z_streamp strm
, const Byte
*dictionary
,
763 struct inflate_state
*state
;
767 if (strm
== NULL
|| strm
->state
== NULL
) return Z_STREAM_ERROR
;
768 state
= (struct inflate_state
*)strm
->state
;
769 if (state
->wrap
!= 0 && state
->mode
!= DICT
)
770 return Z_STREAM_ERROR
;
772 /* check for correct dictionary id */
773 if (state
->mode
== DICT
) {
774 id
= zlib_adler32(0L, NULL
, 0);
775 id
= zlib_adler32(id
, dictionary
, dictLength
);
776 if (id
!= state
->check
)
780 /* copy dictionary to window */
781 zlib_updatewindow(strm
, strm
->avail_out
);
783 if (dictLength
> state
->wsize
) {
784 memcpy(state
->window
, dictionary
+ dictLength
- state
->wsize
,
786 state
->whave
= state
->wsize
;
789 memcpy(state
->window
+ state
->wsize
- dictLength
, dictionary
,
791 state
->whave
= dictLength
;
800 Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
801 or when out of input. When called, *have is the number of pattern bytes
802 found in order so far, in 0..3. On return *have is updated to the new
803 state. If on return *have equals four, then the pattern was found and the
804 return value is how many bytes were read including the last byte of the
805 pattern. If *have is less than four, then the pattern has not been found
806 yet and the return value is len. In the latter case, zlib_syncsearch() can be
807 called again with more data and the *have state. *have is initialized to
808 zero for the first call.
810 static unsigned zlib_syncsearch(unsigned *have
, unsigned char *buf
,
818 while (next
< len
&& got
< 4) {
819 if ((int)(buf
[next
]) == (got
< 2 ? 0 : 0xff))
833 int zlib_inflateSync(z_streamp strm
)
835 unsigned len
; /* number of bytes to look at or looked at */
836 unsigned long in
, out
; /* temporary to save total_in and total_out */
837 unsigned char buf
[4]; /* to restore bit buffer to byte string */
838 struct inflate_state
*state
;
840 /* check parameters */
841 if (strm
== NULL
|| strm
->state
== NULL
) return Z_STREAM_ERROR
;
842 state
= (struct inflate_state
*)strm
->state
;
843 if (strm
->avail_in
== 0 && state
->bits
< 8) return Z_BUF_ERROR
;
845 /* if first time, start search in bit buffer */
846 if (state
->mode
!= SYNC
) {
848 state
->hold
<<= state
->bits
& 7;
849 state
->bits
-= state
->bits
& 7;
851 while (state
->bits
>= 8) {
852 buf
[len
++] = (unsigned char)(state
->hold
);
857 zlib_syncsearch(&(state
->have
), buf
, len
);
860 /* search available input */
861 len
= zlib_syncsearch(&(state
->have
), strm
->next_in
, strm
->avail_in
);
862 strm
->avail_in
-= len
;
863 strm
->next_in
+= len
;
864 strm
->total_in
+= len
;
866 /* return no joy or set up to restart inflate() on a new block */
867 if (state
->have
!= 4) return Z_DATA_ERROR
;
868 in
= strm
->total_in
; out
= strm
->total_out
;
869 zlib_inflateReset(strm
);
870 strm
->total_in
= in
; strm
->total_out
= out
;
877 * This subroutine adds the data at next_in/avail_in to the output history
878 * without performing any output. The output buffer must be "caught up";
879 * i.e. no pending output but this should always be the case. The state must
880 * be waiting on the start of a block (i.e. mode == TYPE or HEAD). On exit,
881 * the output will also be caught up, and the checksum will have been updated
884 int zlib_inflateIncomp(z_stream
*z
)
886 struct inflate_state
*state
= (struct inflate_state
*)z
->state
;
887 Byte
*saved_no
= z
->next_out
;
888 uInt saved_ao
= z
->avail_out
;
890 if (state
->mode
!= TYPE
&& state
->mode
!= HEAD
)
893 /* Setup some variables to allow misuse of updateWindow */
895 z
->next_out
= z
->next_in
+ z
->avail_in
;
897 zlib_updatewindow(z
, z
->avail_in
);
899 /* Restore saved variables */
900 z
->avail_out
= saved_ao
;
901 z
->next_out
= saved_no
;
903 z
->adler
= state
->check
=
904 UPDATE(state
->check
, z
->next_in
, z
->avail_in
);
906 z
->total_out
+= z
->avail_in
;
907 z
->total_in
+= z
->avail_in
;
908 z
->next_in
+= z
->avail_in
;
909 state
->total
+= z
->avail_in
;