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
4 *
5 * Based on zlib 1.2.3 but modified for the Linux Kernel by
6 * Richard Purdie <richard@openedhand.com>
7 *
8 * Changes mainly for static instead of dynamic memory allocation
9 *
10 */
11
12 #include <linux/zutil.h>
13 #include "inftrees.h"
14 #include "inflate.h"
15 #include "inffast.h"
16 #include "infutil.h"
17
zlib_inflate_workspacesize(void)18 int zlib_inflate_workspacesize(void)
19 {
20 return sizeof(struct inflate_workspace);
21 }
22
zlib_inflateReset(z_streamp strm)23 int zlib_inflateReset(z_streamp strm)
24 {
25 struct inflate_state *state;
26
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;
30 strm->msg = NULL;
31 strm->adler = 1; /* to support ill-conceived Java test suite */
32 state->mode = HEAD;
33 state->last = 0;
34 state->havedict = 0;
35 state->dmax = 32768U;
36 state->hold = 0;
37 state->bits = 0;
38 state->lencode = state->distcode = state->next = state->codes;
39
40 /* Initialise Window */
41 state->wsize = 1U << state->wbits;
42 state->write = 0;
43 state->whave = 0;
44
45 return Z_OK;
46 }
47
zlib_inflateInit2(z_streamp strm,int windowBits)48 int zlib_inflateInit2(z_streamp strm, int windowBits)
49 {
50 struct inflate_state *state;
51
52 if (strm == NULL) return Z_STREAM_ERROR;
53 strm->msg = NULL; /* in case we return an error */
54
55 state = &WS(strm)->inflate_state;
56 strm->state = (struct internal_state *)state;
57
58 if (windowBits < 0) {
59 state->wrap = 0;
60 windowBits = -windowBits;
61 }
62 else {
63 state->wrap = (windowBits >> 4) + 1;
64 }
65 if (windowBits < 8 || windowBits > 15) {
66 return Z_STREAM_ERROR;
67 }
68 state->wbits = (unsigned)windowBits;
69 state->window = &WS(strm)->working_window[0];
70
71 return zlib_inflateReset(strm);
72 }
73
74 /*
75 Return state with length and distance decoding tables and index sizes set to
76 fixed code decoding. This returns fixed tables from inffixed.h.
77 */
zlib_fixedtables(struct inflate_state * state)78 static void zlib_fixedtables(struct inflate_state *state)
79 {
80 # include "inffixed.h"
81 state->lencode = lenfix;
82 state->lenbits = 9;
83 state->distcode = distfix;
84 state->distbits = 5;
85 }
86
87
88 /*
89 Update the window with the last wsize (normally 32K) bytes written before
90 returning. This is only called when a window is already in use, or when
91 output has been written during this inflate call, but the end of the deflate
92 stream has not been reached yet. It is also called to window dictionary data
93 when a dictionary is loaded.
94
95 Providing output buffers larger than 32K to inflate() should provide a speed
96 advantage, since only the last 32K of output is copied to the sliding window
97 upon return from inflate(), and since all distances after the first 32K of
98 output will fall in the output data, making match copies simpler and faster.
99 The advantage may be dependent on the size of the processor's data caches.
100 */
zlib_updatewindow(z_streamp strm,unsigned out)101 static void zlib_updatewindow(z_streamp strm, unsigned out)
102 {
103 struct inflate_state *state;
104 unsigned copy, dist;
105
106 state = (struct inflate_state *)strm->state;
107
108 /* copy state->wsize or less output bytes into the circular window */
109 copy = out - strm->avail_out;
110 if (copy >= state->wsize) {
111 memcpy(state->window, strm->next_out - state->wsize, state->wsize);
112 state->write = 0;
113 state->whave = state->wsize;
114 }
115 else {
116 dist = state->wsize - state->write;
117 if (dist > copy) dist = copy;
118 memcpy(state->window + state->write, strm->next_out - copy, dist);
119 copy -= dist;
120 if (copy) {
121 memcpy(state->window, strm->next_out - copy, copy);
122 state->write = copy;
123 state->whave = state->wsize;
124 }
125 else {
126 state->write += dist;
127 if (state->write == state->wsize) state->write = 0;
128 if (state->whave < state->wsize) state->whave += dist;
129 }
130 }
131 }
132
133
134 /*
135 * At the end of a Deflate-compressed PPP packet, we expect to have seen
136 * a `stored' block type value but not the (zero) length bytes.
137 */
138 /*
139 Returns true if inflate is currently at the end of a block generated by
140 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
141 implementation to provide an additional safety check. PPP uses
142 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
143 block. When decompressing, PPP checks that at the end of input packet,
144 inflate is waiting for these length bytes.
145 */
zlib_inflateSyncPacket(z_streamp strm)146 static int zlib_inflateSyncPacket(z_streamp strm)
147 {
148 struct inflate_state *state;
149
150 if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
151 state = (struct inflate_state *)strm->state;
152
153 if (state->mode == STORED && state->bits == 0) {
154 state->mode = TYPE;
155 return Z_OK;
156 }
157 return Z_DATA_ERROR;
158 }
159
160 /* Macros for inflate(): */
161
162 /* check function to use adler32() for zlib or crc32() for gzip */
163 #define UPDATE(check, buf, len) zlib_adler32(check, buf, len)
164
165 /* Load registers with state in inflate() for speed */
166 #define LOAD() \
167 do { \
168 put = strm->next_out; \
169 left = strm->avail_out; \
170 next = strm->next_in; \
171 have = strm->avail_in; \
172 hold = state->hold; \
173 bits = state->bits; \
174 } while (0)
175
176 /* Restore state from registers in inflate() */
177 #define RESTORE() \
178 do { \
179 strm->next_out = put; \
180 strm->avail_out = left; \
181 strm->next_in = next; \
182 strm->avail_in = have; \
183 state->hold = hold; \
184 state->bits = bits; \
185 } while (0)
186
187 /* Clear the input bit accumulator */
188 #define INITBITS() \
189 do { \
190 hold = 0; \
191 bits = 0; \
192 } while (0)
193
194 /* Get a byte of input into the bit accumulator, or return from inflate()
195 if there is no input available. */
196 #define PULLBYTE() \
197 do { \
198 if (have == 0) goto inf_leave; \
199 have--; \
200 hold += (unsigned long)(*next++) << bits; \
201 bits += 8; \
202 } while (0)
203
204 /* Assure that there are at least n bits in the bit accumulator. If there is
205 not enough available input to do that, then return from inflate(). */
206 #define NEEDBITS(n) \
207 do { \
208 while (bits < (unsigned)(n)) \
209 PULLBYTE(); \
210 } while (0)
211
212 /* Return the low n bits of the bit accumulator (n < 16) */
213 #define BITS(n) \
214 ((unsigned)hold & ((1U << (n)) - 1))
215
216 /* Remove n bits from the bit accumulator */
217 #define DROPBITS(n) \
218 do { \
219 hold >>= (n); \
220 bits -= (unsigned)(n); \
221 } while (0)
222
223 /* Remove zero to seven bits as needed to go to a byte boundary */
224 #define BYTEBITS() \
225 do { \
226 hold >>= bits & 7; \
227 bits -= bits & 7; \
228 } while (0)
229
230 /* Reverse the bytes in a 32-bit value */
231 #define REVERSE(q) \
232 ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
233 (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
234
235 /*
236 inflate() uses a state machine to process as much input data and generate as
237 much output data as possible before returning. The state machine is
238 structured roughly as follows:
239
240 for (;;) switch (state) {
241 ...
242 case STATEn:
243 if (not enough input data or output space to make progress)
244 return;
245 ... make progress ...
246 state = STATEm;
247 break;
248 ...
249 }
250
251 so when inflate() is called again, the same case is attempted again, and
252 if the appropriate resources are provided, the machine proceeds to the
253 next state. The NEEDBITS() macro is usually the way the state evaluates
254 whether it can proceed or should return. NEEDBITS() does the return if
255 the requested bits are not available. The typical use of the BITS macros
256 is:
257
258 NEEDBITS(n);
259 ... do something with BITS(n) ...
260 DROPBITS(n);
261
262 where NEEDBITS(n) either returns from inflate() if there isn't enough
263 input left to load n bits into the accumulator, or it continues. BITS(n)
264 gives the low n bits in the accumulator. When done, DROPBITS(n) drops
265 the low n bits off the accumulator. INITBITS() clears the accumulator
266 and sets the number of available bits to zero. BYTEBITS() discards just
267 enough bits to put the accumulator on a byte boundary. After BYTEBITS()
268 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
269
270 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
271 if there is no input available. The decoding of variable length codes uses
272 PULLBYTE() directly in order to pull just enough bytes to decode the next
273 code, and no more.
274
275 Some states loop until they get enough input, making sure that enough
276 state information is maintained to continue the loop where it left off
277 if NEEDBITS() returns in the loop. For example, want, need, and keep
278 would all have to actually be part of the saved state in case NEEDBITS()
279 returns:
280
281 case STATEw:
282 while (want < need) {
283 NEEDBITS(n);
284 keep[want++] = BITS(n);
285 DROPBITS(n);
286 }
287 state = STATEx;
288 case STATEx:
289
290 As shown above, if the next state is also the next case, then the break
291 is omitted.
292
293 A state may also return if there is not enough output space available to
294 complete that state. Those states are copying stored data, writing a
295 literal byte, and copying a matching string.
296
297 When returning, a "goto inf_leave" is used to update the total counters,
298 update the check value, and determine whether any progress has been made
299 during that inflate() call in order to return the proper return code.
300 Progress is defined as a change in either strm->avail_in or strm->avail_out.
301 When there is a window, goto inf_leave will update the window with the last
302 output written. If a goto inf_leave occurs in the middle of decompression
303 and there is no window currently, goto inf_leave will create one and copy
304 output to the window for the next call of inflate().
305
306 In this implementation, the flush parameter of inflate() only affects the
307 return code (per zlib.h). inflate() always writes as much as possible to
308 strm->next_out, given the space available and the provided input--the effect
309 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
310 the allocation of and copying into a sliding window until necessary, which
311 provides the effect documented in zlib.h for Z_FINISH when the entire input
312 stream available. So the only thing the flush parameter actually does is:
313 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
314 will return Z_BUF_ERROR if it has not reached the end of the stream.
315 */
316
zlib_inflate(z_streamp strm,int flush)317 int zlib_inflate(z_streamp strm, int flush)
318 {
319 struct inflate_state *state;
320 const unsigned char *next; /* next input */
321 unsigned char *put; /* next output */
322 unsigned have, left; /* available input and output */
323 unsigned long hold; /* bit buffer */
324 unsigned bits; /* bits in bit buffer */
325 unsigned in, out; /* save starting available input and output */
326 unsigned copy; /* number of stored or match bytes to copy */
327 unsigned char *from; /* where to copy match bytes from */
328 code this; /* current decoding table entry */
329 code last; /* parent table entry */
330 unsigned len; /* length to copy for repeats, bits to drop */
331 int ret; /* return code */
332 static const unsigned short order[19] = /* permutation of code lengths */
333 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
334
335 /* Do not check for strm->next_out == NULL here as ppc zImage
336 inflates to strm->next_out = 0 */
337
338 if (strm == NULL || strm->state == NULL ||
339 (strm->next_in == NULL && strm->avail_in != 0))
340 return Z_STREAM_ERROR;
341
342 state = (struct inflate_state *)strm->state;
343
344 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
345 LOAD();
346 in = have;
347 out = left;
348 ret = Z_OK;
349 for (;;)
350 switch (state->mode) {
351 case HEAD:
352 if (state->wrap == 0) {
353 state->mode = TYPEDO;
354 break;
355 }
356 NEEDBITS(16);
357 if (
358 ((BITS(8) << 8) + (hold >> 8)) % 31) {
359 strm->msg = (char *)"incorrect header check";
360 state->mode = BAD;
361 break;
362 }
363 if (BITS(4) != Z_DEFLATED) {
364 strm->msg = (char *)"unknown compression method";
365 state->mode = BAD;
366 break;
367 }
368 DROPBITS(4);
369 len = BITS(4) + 8;
370 if (len > state->wbits) {
371 strm->msg = (char *)"invalid window size";
372 state->mode = BAD;
373 break;
374 }
375 state->dmax = 1U << len;
376 strm->adler = state->check = zlib_adler32(0L, NULL, 0);
377 state->mode = hold & 0x200 ? DICTID : TYPE;
378 INITBITS();
379 break;
380 case DICTID:
381 NEEDBITS(32);
382 strm->adler = state->check = REVERSE(hold);
383 INITBITS();
384 state->mode = DICT;
385 case DICT:
386 if (state->havedict == 0) {
387 RESTORE();
388 return Z_NEED_DICT;
389 }
390 strm->adler = state->check = zlib_adler32(0L, NULL, 0);
391 state->mode = TYPE;
392 case TYPE:
393 if (flush == Z_BLOCK) goto inf_leave;
394 case TYPEDO:
395 if (state->last) {
396 BYTEBITS();
397 state->mode = CHECK;
398 break;
399 }
400 NEEDBITS(3);
401 state->last = BITS(1);
402 DROPBITS(1);
403 switch (BITS(2)) {
404 case 0: /* stored block */
405 state->mode = STORED;
406 break;
407 case 1: /* fixed block */
408 zlib_fixedtables(state);
409 state->mode = LEN; /* decode codes */
410 break;
411 case 2: /* dynamic block */
412 state->mode = TABLE;
413 break;
414 case 3:
415 strm->msg = (char *)"invalid block type";
416 state->mode = BAD;
417 }
418 DROPBITS(2);
419 break;
420 case STORED:
421 BYTEBITS(); /* go to byte boundary */
422 NEEDBITS(32);
423 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
424 strm->msg = (char *)"invalid stored block lengths";
425 state->mode = BAD;
426 break;
427 }
428 state->length = (unsigned)hold & 0xffff;
429 INITBITS();
430 state->mode = COPY;
431 case COPY:
432 copy = state->length;
433 if (copy) {
434 if (copy > have) copy = have;
435 if (copy > left) copy = left;
436 if (copy == 0) goto inf_leave;
437 memcpy(put, next, copy);
438 have -= copy;
439 next += copy;
440 left -= copy;
441 put += copy;
442 state->length -= copy;
443 break;
444 }
445 state->mode = TYPE;
446 break;
447 case TABLE:
448 NEEDBITS(14);
449 state->nlen = BITS(5) + 257;
450 DROPBITS(5);
451 state->ndist = BITS(5) + 1;
452 DROPBITS(5);
453 state->ncode = BITS(4) + 4;
454 DROPBITS(4);
455 #ifndef PKZIP_BUG_WORKAROUND
456 if (state->nlen > 286 || state->ndist > 30) {
457 strm->msg = (char *)"too many length or distance symbols";
458 state->mode = BAD;
459 break;
460 }
461 #endif
462 state->have = 0;
463 state->mode = LENLENS;
464 case LENLENS:
465 while (state->have < state->ncode) {
466 NEEDBITS(3);
467 state->lens[order[state->have++]] = (unsigned short)BITS(3);
468 DROPBITS(3);
469 }
470 while (state->have < 19)
471 state->lens[order[state->have++]] = 0;
472 state->next = state->codes;
473 state->lencode = (code const *)(state->next);
474 state->lenbits = 7;
475 ret = zlib_inflate_table(CODES, state->lens, 19, &(state->next),
476 &(state->lenbits), state->work);
477 if (ret) {
478 strm->msg = (char *)"invalid code lengths set";
479 state->mode = BAD;
480 break;
481 }
482 state->have = 0;
483 state->mode = CODELENS;
484 case CODELENS:
485 while (state->have < state->nlen + state->ndist) {
486 for (;;) {
487 this = state->lencode[BITS(state->lenbits)];
488 if ((unsigned)(this.bits) <= bits) break;
489 PULLBYTE();
490 }
491 if (this.val < 16) {
492 NEEDBITS(this.bits);
493 DROPBITS(this.bits);
494 state->lens[state->have++] = this.val;
495 }
496 else {
497 if (this.val == 16) {
498 NEEDBITS(this.bits + 2);
499 DROPBITS(this.bits);
500 if (state->have == 0) {
501 strm->msg = (char *)"invalid bit length repeat";
502 state->mode = BAD;
503 break;
504 }
505 len = state->lens[state->have - 1];
506 copy = 3 + BITS(2);
507 DROPBITS(2);
508 }
509 else if (this.val == 17) {
510 NEEDBITS(this.bits + 3);
511 DROPBITS(this.bits);
512 len = 0;
513 copy = 3 + BITS(3);
514 DROPBITS(3);
515 }
516 else {
517 NEEDBITS(this.bits + 7);
518 DROPBITS(this.bits);
519 len = 0;
520 copy = 11 + BITS(7);
521 DROPBITS(7);
522 }
523 if (state->have + copy > state->nlen + state->ndist) {
524 strm->msg = (char *)"invalid bit length repeat";
525 state->mode = BAD;
526 break;
527 }
528 while (copy--)
529 state->lens[state->have++] = (unsigned short)len;
530 }
531 }
532
533 /* handle error breaks in while */
534 if (state->mode == BAD) break;
535
536 /* build code tables */
537 state->next = state->codes;
538 state->lencode = (code const *)(state->next);
539 state->lenbits = 9;
540 ret = zlib_inflate_table(LENS, state->lens, state->nlen, &(state->next),
541 &(state->lenbits), state->work);
542 if (ret) {
543 strm->msg = (char *)"invalid literal/lengths set";
544 state->mode = BAD;
545 break;
546 }
547 state->distcode = (code const *)(state->next);
548 state->distbits = 6;
549 ret = zlib_inflate_table(DISTS, state->lens + state->nlen, state->ndist,
550 &(state->next), &(state->distbits), state->work);
551 if (ret) {
552 strm->msg = (char *)"invalid distances set";
553 state->mode = BAD;
554 break;
555 }
556 state->mode = LEN;
557 case LEN:
558 if (have >= 6 && left >= 258) {
559 RESTORE();
560 inflate_fast(strm, out);
561 LOAD();
562 break;
563 }
564 for (;;) {
565 this = state->lencode[BITS(state->lenbits)];
566 if ((unsigned)(this.bits) <= bits) break;
567 PULLBYTE();
568 }
569 if (this.op && (this.op & 0xf0) == 0) {
570 last = this;
571 for (;;) {
572 this = state->lencode[last.val +
573 (BITS(last.bits + last.op) >> last.bits)];
574 if ((unsigned)(last.bits + this.bits) <= bits) break;
575 PULLBYTE();
576 }
577 DROPBITS(last.bits);
578 }
579 DROPBITS(this.bits);
580 state->length = (unsigned)this.val;
581 if ((int)(this.op) == 0) {
582 state->mode = LIT;
583 break;
584 }
585 if (this.op & 32) {
586 state->mode = TYPE;
587 break;
588 }
589 if (this.op & 64) {
590 strm->msg = (char *)"invalid literal/length code";
591 state->mode = BAD;
592 break;
593 }
594 state->extra = (unsigned)(this.op) & 15;
595 state->mode = LENEXT;
596 case LENEXT:
597 if (state->extra) {
598 NEEDBITS(state->extra);
599 state->length += BITS(state->extra);
600 DROPBITS(state->extra);
601 }
602 state->mode = DIST;
603 case DIST:
604 for (;;) {
605 this = state->distcode[BITS(state->distbits)];
606 if ((unsigned)(this.bits) <= bits) break;
607 PULLBYTE();
608 }
609 if ((this.op & 0xf0) == 0) {
610 last = this;
611 for (;;) {
612 this = state->distcode[last.val +
613 (BITS(last.bits + last.op) >> last.bits)];
614 if ((unsigned)(last.bits + this.bits) <= bits) break;
615 PULLBYTE();
616 }
617 DROPBITS(last.bits);
618 }
619 DROPBITS(this.bits);
620 if (this.op & 64) {
621 strm->msg = (char *)"invalid distance code";
622 state->mode = BAD;
623 break;
624 }
625 state->offset = (unsigned)this.val;
626 state->extra = (unsigned)(this.op) & 15;
627 state->mode = DISTEXT;
628 case DISTEXT:
629 if (state->extra) {
630 NEEDBITS(state->extra);
631 state->offset += BITS(state->extra);
632 DROPBITS(state->extra);
633 }
634 #ifdef INFLATE_STRICT
635 if (state->offset > state->dmax) {
636 strm->msg = (char *)"invalid distance too far back";
637 state->mode = BAD;
638 break;
639 }
640 #endif
641 if (state->offset > state->whave + out - left) {
642 strm->msg = (char *)"invalid distance too far back";
643 state->mode = BAD;
644 break;
645 }
646 state->mode = MATCH;
647 case MATCH:
648 if (left == 0) goto inf_leave;
649 copy = out - left;
650 if (state->offset > copy) { /* copy from window */
651 copy = state->offset - copy;
652 if (copy > state->write) {
653 copy -= state->write;
654 from = state->window + (state->wsize - copy);
655 }
656 else
657 from = state->window + (state->write - copy);
658 if (copy > state->length) copy = state->length;
659 }
660 else { /* copy from output */
661 from = put - state->offset;
662 copy = state->length;
663 }
664 if (copy > left) copy = left;
665 left -= copy;
666 state->length -= copy;
667 do {
668 *put++ = *from++;
669 } while (--copy);
670 if (state->length == 0) state->mode = LEN;
671 break;
672 case LIT:
673 if (left == 0) goto inf_leave;
674 *put++ = (unsigned char)(state->length);
675 left--;
676 state->mode = LEN;
677 break;
678 case CHECK:
679 if (state->wrap) {
680 NEEDBITS(32);
681 out -= left;
682 strm->total_out += out;
683 state->total += out;
684 if (out)
685 strm->adler = state->check =
686 UPDATE(state->check, put - out, out);
687 out = left;
688 if ((
689 REVERSE(hold)) != state->check) {
690 strm->msg = (char *)"incorrect data check";
691 state->mode = BAD;
692 break;
693 }
694 INITBITS();
695 }
696 state->mode = DONE;
697 case DONE:
698 ret = Z_STREAM_END;
699 goto inf_leave;
700 case BAD:
701 ret = Z_DATA_ERROR;
702 goto inf_leave;
703 case MEM:
704 return Z_MEM_ERROR;
705 case SYNC:
706 default:
707 return Z_STREAM_ERROR;
708 }
709
710 /*
711 Return from inflate(), updating the total counts and the check value.
712 If there was no progress during the inflate() call, return a buffer
713 error. Call zlib_updatewindow() to create and/or update the window state.
714 */
715 inf_leave:
716 RESTORE();
717 if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
718 zlib_updatewindow(strm, out);
719
720 in -= strm->avail_in;
721 out -= strm->avail_out;
722 strm->total_in += in;
723 strm->total_out += out;
724 state->total += out;
725 if (state->wrap && out)
726 strm->adler = state->check =
727 UPDATE(state->check, strm->next_out - out, out);
728
729 strm->data_type = state->bits + (state->last ? 64 : 0) +
730 (state->mode == TYPE ? 128 : 0);
731
732 if (flush == Z_PACKET_FLUSH && ret == Z_OK &&
733 strm->avail_out != 0 && strm->avail_in == 0)
734 return zlib_inflateSyncPacket(strm);
735
736 if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
737 ret = Z_BUF_ERROR;
738
739 return ret;
740 }
741
zlib_inflateEnd(z_streamp strm)742 int zlib_inflateEnd(z_streamp strm)
743 {
744 if (strm == NULL || strm->state == NULL)
745 return Z_STREAM_ERROR;
746 return Z_OK;
747 }
748
749 /*
750 * This subroutine adds the data at next_in/avail_in to the output history
751 * without performing any output. The output buffer must be "caught up";
752 * i.e. no pending output but this should always be the case. The state must
753 * be waiting on the start of a block (i.e. mode == TYPE or HEAD). On exit,
754 * the output will also be caught up, and the checksum will have been updated
755 * if need be.
756 */
zlib_inflateIncomp(z_stream * z)757 int zlib_inflateIncomp(z_stream *z)
758 {
759 struct inflate_state *state = (struct inflate_state *)z->state;
760 Byte *saved_no = z->next_out;
761 uInt saved_ao = z->avail_out;
762
763 if (state->mode != TYPE && state->mode != HEAD)
764 return Z_DATA_ERROR;
765
766 /* Setup some variables to allow misuse of updateWindow */
767 z->avail_out = 0;
768 z->next_out = (unsigned char*)z->next_in + z->avail_in;
769
770 zlib_updatewindow(z, z->avail_in);
771
772 /* Restore saved variables */
773 z->avail_out = saved_ao;
774 z->next_out = saved_no;
775
776 z->adler = state->check =
777 UPDATE(state->check, z->next_in, z->avail_in);
778
779 z->total_out += z->avail_in;
780 z->total_in += z->avail_in;
781 z->next_in += z->avail_in;
782 state->total += z->avail_in;
783 z->avail_in = 0;
784
785 return Z_OK;
786 }
787