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