• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* infback.c -- inflate using a call-back interface
2  * Copyright (C) 1995-2022 Mark Adler
3  * For conditions of distribution and use, see copyright notice in zlib.h
4  */
5 
6 /*
7    This code is largely copied from inflate.c.  Normally either infback.o or
8    inflate.o would be linked into an application--not both.  The interface
9    with inffast.c is retained so that optimized assembler-coded versions of
10    inflate_fast() can be used with either inflate.c or infback.c.
11  */
12 
13 #include "zutil.h"
14 #include "inftrees.h"
15 #include "inflate.h"
16 #include "inffast.h"
17 
18 /*
19    strm provides memory allocation functions in zalloc and zfree, or
20    Z_NULL to use the library memory allocation functions.
21 
22    windowBits is in the range 8..15, and window is a user-supplied
23    window and output buffer that is 2**windowBits bytes.
24  */
inflateBackInit_(z_streamp strm,int windowBits,unsigned char FAR * window,const char * version,int stream_size)25 int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits,
26                              unsigned char FAR *window, const char *version,
27                              int stream_size) {
28     struct inflate_state FAR *state;
29 
30     if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
31         stream_size != (int)(sizeof(z_stream)))
32         return Z_VERSION_ERROR;
33     if (strm == Z_NULL || window == Z_NULL ||
34         windowBits < 8 || windowBits > 15)
35         return Z_STREAM_ERROR;
36     strm->msg = Z_NULL;                 /* in case we return an error */
37     if (strm->zalloc == (alloc_func)0) {
38 #ifdef Z_SOLO
39         return Z_STREAM_ERROR;
40 #else
41         strm->zalloc = zcalloc;
42         strm->opaque = (voidpf)0;
43 #endif
44     }
45     if (strm->zfree == (free_func)0)
46 #ifdef Z_SOLO
47         return Z_STREAM_ERROR;
48 #else
49     strm->zfree = zcfree;
50 #endif
51     state = (struct inflate_state FAR *)ZALLOC(strm, 1,
52                                                sizeof(struct inflate_state));
53     if (state == Z_NULL) return Z_MEM_ERROR;
54     Tracev((stderr, "inflate: allocated\n"));
55     strm->state = (struct internal_state FAR *)state;
56     state->dmax = 32768U;
57     state->wbits = (uInt)windowBits;
58     state->wsize = 1U << windowBits;
59     state->window = window;
60     state->wnext = 0;
61     state->whave = 0;
62     state->sane = 1;
63     return Z_OK;
64 }
65 
66 /*
67    Return state with length and distance decoding tables and index sizes set to
68    fixed code decoding.  Normally this returns fixed tables from inffixed.h.
69    If BUILDFIXED is defined, then instead this routine builds the tables the
70    first time it's called, and returns those tables the first time and
71    thereafter.  This reduces the size of the code by about 2K bytes, in
72    exchange for a little execution time.  However, BUILDFIXED should not be
73    used for threaded applications, since the rewriting of the tables and virgin
74    may not be thread-safe.
75  */
fixedtables(struct inflate_state FAR * state)76 local void fixedtables(struct inflate_state FAR *state) {
77 #ifdef BUILDFIXED
78     static int virgin = 1;
79     static code *lenfix, *distfix;
80     static code fixed[544];
81 
82     /* build fixed huffman tables if first call (may not be thread safe) */
83     if (virgin) {
84         unsigned sym, bits;
85         static code *next;
86 
87         /* literal/length table */
88         sym = 0;
89         while (sym < 144) state->lens[sym++] = 8;
90         while (sym < 256) state->lens[sym++] = 9;
91         while (sym < 280) state->lens[sym++] = 7;
92         while (sym < 288) state->lens[sym++] = 8;
93         next = fixed;
94         lenfix = next;
95         bits = 9;
96         inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
97 
98         /* distance table */
99         sym = 0;
100         while (sym < 32) state->lens[sym++] = 5;
101         distfix = next;
102         bits = 5;
103         inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
104 
105         /* do this just once */
106         virgin = 0;
107     }
108 #else /* !BUILDFIXED */
109 #   include "inffixed.h"
110 #endif /* BUILDFIXED */
111     state->lencode = lenfix;
112     state->lenbits = 9;
113     state->distcode = distfix;
114     state->distbits = 5;
115 }
116 
117 /* Macros for inflateBack(): */
118 
119 /* Load returned state from inflate_fast() */
120 #define LOAD() \
121     do { \
122         put = strm->next_out; \
123         left = strm->avail_out; \
124         next = strm->next_in; \
125         have = strm->avail_in; \
126         hold = state->hold; \
127         bits = state->bits; \
128     } while (0)
129 
130 /* Set state from registers for inflate_fast() */
131 #define RESTORE() \
132     do { \
133         strm->next_out = put; \
134         strm->avail_out = left; \
135         strm->next_in = next; \
136         strm->avail_in = have; \
137         state->hold = hold; \
138         state->bits = bits; \
139     } while (0)
140 
141 /* Clear the input bit accumulator */
142 #define INITBITS() \
143     do { \
144         hold = 0; \
145         bits = 0; \
146     } while (0)
147 
148 /* Assure that some input is available.  If input is requested, but denied,
149    then return a Z_BUF_ERROR from inflateBack(). */
150 #define PULL() \
151     do { \
152         if (have == 0) { \
153             have = in(in_desc, &next); \
154             if (have == 0) { \
155                 next = Z_NULL; \
156                 ret = Z_BUF_ERROR; \
157                 goto inf_leave; \
158             } \
159         } \
160     } while (0)
161 
162 /* Get a byte of input into the bit accumulator, or return from inflateBack()
163    with an error if there is no input available. */
164 #define PULLBYTE() \
165     do { \
166         PULL(); \
167         have--; \
168         hold += (unsigned long)(*next++) << bits; \
169         bits += 8; \
170     } while (0)
171 
172 /* Assure that there are at least n bits in the bit accumulator.  If there is
173    not enough available input to do that, then return from inflateBack() with
174    an error. */
175 #define NEEDBITS(n) \
176     do { \
177         while (bits < (unsigned)(n)) \
178             PULLBYTE(); \
179     } while (0)
180 
181 /* Return the low n bits of the bit accumulator (n < 16) */
182 #define BITS(n) \
183     ((unsigned)hold & ((1U << (n)) - 1))
184 
185 /* Remove n bits from the bit accumulator */
186 #define DROPBITS(n) \
187     do { \
188         hold >>= (n); \
189         bits -= (unsigned)(n); \
190     } while (0)
191 
192 /* Remove zero to seven bits as needed to go to a byte boundary */
193 #define BYTEBITS() \
194     do { \
195         hold >>= bits & 7; \
196         bits -= bits & 7; \
197     } while (0)
198 
199 /* Assure that some output space is available, by writing out the window
200    if it's full.  If the write fails, return from inflateBack() with a
201    Z_BUF_ERROR. */
202 #define ROOM() \
203     do { \
204         if (left == 0) { \
205             put = state->window; \
206             left = state->wsize; \
207             state->whave = left; \
208             if (out(out_desc, put, left)) { \
209                 ret = Z_BUF_ERROR; \
210                 goto inf_leave; \
211             } \
212         } \
213     } while (0)
214 
215 /*
216    strm provides the memory allocation functions and window buffer on input,
217    and provides information on the unused input on return.  For Z_DATA_ERROR
218    returns, strm will also provide an error message.
219 
220    in() and out() are the call-back input and output functions.  When
221    inflateBack() needs more input, it calls in().  When inflateBack() has
222    filled the window with output, or when it completes with data in the
223    window, it calls out() to write out the data.  The application must not
224    change the provided input until in() is called again or inflateBack()
225    returns.  The application must not change the window/output buffer until
226    inflateBack() returns.
227 
228    in() and out() are called with a descriptor parameter provided in the
229    inflateBack() call.  This parameter can be a structure that provides the
230    information required to do the read or write, as well as accumulated
231    information on the input and output such as totals and check values.
232 
233    in() should return zero on failure.  out() should return non-zero on
234    failure.  If either in() or out() fails, than inflateBack() returns a
235    Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
236    was in() or out() that caused in the error.  Otherwise,  inflateBack()
237    returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
238    error, or Z_MEM_ERROR if it could not allocate memory for the state.
239    inflateBack() can also return Z_STREAM_ERROR if the input parameters
240    are not correct, i.e. strm is Z_NULL or the state was not initialized.
241  */
inflateBack(z_streamp strm,in_func in,void FAR * in_desc,out_func out,void FAR * out_desc)242 int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR *in_desc,
243                         out_func out, void FAR *out_desc) {
244     struct inflate_state FAR *state;
245     z_const unsigned char FAR *next;    /* next input */
246     unsigned char FAR *put;     /* next output */
247     unsigned have, left;        /* available input and output */
248     unsigned long hold;         /* bit buffer */
249     unsigned bits;              /* bits in bit buffer */
250     unsigned copy;              /* number of stored or match bytes to copy */
251     unsigned char FAR *from;    /* where to copy match bytes from */
252     code here;                  /* current decoding table entry */
253     code last;                  /* parent table entry */
254     unsigned len;               /* length to copy for repeats, bits to drop */
255     int ret;                    /* return code */
256     static const unsigned short order[19] = /* permutation of code lengths */
257         {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
258 
259     /* Check that the strm exists and that the state was initialized */
260     if (strm == Z_NULL || strm->state == Z_NULL)
261         return Z_STREAM_ERROR;
262     state = (struct inflate_state FAR *)strm->state;
263 
264     /* Reset the state */
265     strm->msg = Z_NULL;
266     state->mode = TYPE;
267     state->last = 0;
268     state->whave = 0;
269     next = strm->next_in;
270     have = next != Z_NULL ? strm->avail_in : 0;
271     hold = 0;
272     bits = 0;
273     put = state->window;
274     left = state->wsize;
275 
276     /* Inflate until end of block marked as last */
277     for (;;)
278         switch (state->mode) {
279         case TYPE:
280             /* determine and dispatch block type */
281             if (state->last) {
282                 BYTEBITS();
283                 state->mode = DONE;
284                 break;
285             }
286             NEEDBITS(3);
287             state->last = BITS(1);
288             DROPBITS(1);
289             switch (BITS(2)) {
290             case 0:                             /* stored block */
291                 Tracev((stderr, "inflate:     stored block%s\n",
292                         state->last ? " (last)" : ""));
293                 state->mode = STORED;
294                 break;
295             case 1:                             /* fixed block */
296                 fixedtables(state);
297                 Tracev((stderr, "inflate:     fixed codes block%s\n",
298                         state->last ? " (last)" : ""));
299                 state->mode = LEN;              /* decode codes */
300                 break;
301             case 2:                             /* dynamic block */
302                 Tracev((stderr, "inflate:     dynamic codes block%s\n",
303                         state->last ? " (last)" : ""));
304                 state->mode = TABLE;
305                 break;
306             case 3:
307                 strm->msg = (char *)"invalid block type";
308                 state->mode = BAD;
309             }
310             DROPBITS(2);
311             break;
312 
313         case STORED:
314             /* get and verify stored block length */
315             BYTEBITS();                         /* go to byte boundary */
316             NEEDBITS(32);
317             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
318                 strm->msg = (char *)"invalid stored block lengths";
319                 state->mode = BAD;
320                 break;
321             }
322             state->length = (unsigned)hold & 0xffff;
323             Tracev((stderr, "inflate:       stored length %u\n",
324                     state->length));
325             INITBITS();
326 
327             /* copy stored block from input to output */
328             while (state->length != 0) {
329                 copy = state->length;
330                 PULL();
331                 ROOM();
332                 if (copy > have) copy = have;
333                 if (copy > left) copy = left;
334                 zmemcpy(put, next, copy);
335                 have -= copy;
336                 next += copy;
337                 left -= copy;
338                 put += copy;
339                 state->length -= copy;
340             }
341             Tracev((stderr, "inflate:       stored end\n"));
342             state->mode = TYPE;
343             break;
344 
345         case TABLE:
346             /* get dynamic table entries descriptor */
347             NEEDBITS(14);
348             state->nlen = BITS(5) + 257;
349             DROPBITS(5);
350             state->ndist = BITS(5) + 1;
351             DROPBITS(5);
352             state->ncode = BITS(4) + 4;
353             DROPBITS(4);
354 #ifndef PKZIP_BUG_WORKAROUND
355             if (state->nlen > 286 || state->ndist > 30) {
356                 strm->msg = (char *)"too many length or distance symbols";
357                 state->mode = BAD;
358                 break;
359             }
360 #endif
361             Tracev((stderr, "inflate:       table sizes ok\n"));
362 
363             /* get code length code lengths (not a typo) */
364             state->have = 0;
365             while (state->have < state->ncode) {
366                 NEEDBITS(3);
367                 state->lens[order[state->have++]] = (unsigned short)BITS(3);
368                 DROPBITS(3);
369             }
370             while (state->have < 19)
371                 state->lens[order[state->have++]] = 0;
372             state->next = state->codes;
373             state->lencode = (code const FAR *)(state->next);
374             state->lenbits = 7;
375             ret = inflate_table(CODES, state->lens, 19, &(state->next),
376                                 &(state->lenbits), state->work);
377             if (ret) {
378                 strm->msg = (char *)"invalid code lengths set";
379                 state->mode = BAD;
380                 break;
381             }
382             Tracev((stderr, "inflate:       code lengths ok\n"));
383 
384             /* get length and distance code code lengths */
385             state->have = 0;
386             while (state->have < state->nlen + state->ndist) {
387                 for (;;) {
388                     here = state->lencode[BITS(state->lenbits)];
389                     if ((unsigned)(here.bits) <= bits) break;
390                     PULLBYTE();
391                 }
392                 if (here.val < 16) {
393                     DROPBITS(here.bits);
394                     state->lens[state->have++] = here.val;
395                 }
396                 else {
397                     if (here.val == 16) {
398                         NEEDBITS(here.bits + 2);
399                         DROPBITS(here.bits);
400                         if (state->have == 0) {
401                             strm->msg = (char *)"invalid bit length repeat";
402                             state->mode = BAD;
403                             break;
404                         }
405                         len = (unsigned)(state->lens[state->have - 1]);
406                         copy = 3 + BITS(2);
407                         DROPBITS(2);
408                     }
409                     else if (here.val == 17) {
410                         NEEDBITS(here.bits + 3);
411                         DROPBITS(here.bits);
412                         len = 0;
413                         copy = 3 + BITS(3);
414                         DROPBITS(3);
415                     }
416                     else {
417                         NEEDBITS(here.bits + 7);
418                         DROPBITS(here.bits);
419                         len = 0;
420                         copy = 11 + BITS(7);
421                         DROPBITS(7);
422                     }
423                     if (state->have + copy > state->nlen + state->ndist) {
424                         strm->msg = (char *)"invalid bit length repeat";
425                         state->mode = BAD;
426                         break;
427                     }
428                     while (copy--)
429                         state->lens[state->have++] = (unsigned short)len;
430                 }
431             }
432 
433             /* handle error breaks in while */
434             if (state->mode == BAD) break;
435 
436             /* check for end-of-block code (better have one) */
437             if (state->lens[256] == 0) {
438                 strm->msg = (char *)"invalid code -- missing end-of-block";
439                 state->mode = BAD;
440                 break;
441             }
442 
443             /* build code tables -- note: do not change the lenbits or distbits
444                values here (10 and 9) without reading the comments in inftrees.h
445                concerning the ENOUGH constants, which depend on those values */
446             state->next = state->codes;
447             state->lencode = (code const FAR *)(state->next);
448             state->lenbits = 10;
449             ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
450                                 &(state->lenbits), state->work);
451             if (ret) {
452                 strm->msg = (char *)"invalid literal/lengths set";
453                 state->mode = BAD;
454                 break;
455             }
456             state->distcode = (code const FAR *)(state->next);
457             state->distbits = 9;
458             ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
459                             &(state->next), &(state->distbits), state->work);
460             if (ret) {
461                 strm->msg = (char *)"invalid distances set";
462                 state->mode = BAD;
463                 break;
464             }
465             Tracev((stderr, "inflate:       codes ok\n"));
466             state->mode = LEN;
467                 /* fallthrough */
468 
469         case LEN:
470             /* use inflate_fast() if we have enough input and output */
471             if (have >= INFLATE_FAST_MIN_INPUT &&
472                 left >= INFLATE_FAST_MIN_OUTPUT) {
473                 RESTORE();
474                 if (state->whave < state->wsize)
475                     state->whave = state->wsize - left;
476                 inflate_fast(strm, state->wsize);
477                 LOAD();
478                 break;
479             }
480 
481             /* get a literal, length, or end-of-block code */
482             for (;;) {
483                 here = state->lencode[BITS(state->lenbits)];
484                 if ((unsigned)(here.bits) <= bits) break;
485                 PULLBYTE();
486             }
487             if (here.op && (here.op & 0xf0) == 0) {
488                 last = here;
489                 for (;;) {
490                     here = state->lencode[last.val +
491                             (BITS(last.bits + last.op) >> last.bits)];
492                     if ((unsigned)(last.bits + here.bits) <= bits) break;
493                     PULLBYTE();
494                 }
495                 DROPBITS(last.bits);
496             }
497             DROPBITS(here.bits);
498             state->length = (unsigned)here.val;
499 
500             /* process literal */
501             if (here.op == 0) {
502                 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
503                         "inflate:         literal '%c'\n" :
504                         "inflate:         literal 0x%02x\n", here.val));
505                 ROOM();
506                 *put++ = (unsigned char)(state->length);
507                 left--;
508                 state->mode = LEN;
509                 break;
510             }
511 
512             /* process end of block */
513             if (here.op & 32) {
514                 Tracevv((stderr, "inflate:         end of block\n"));
515                 state->mode = TYPE;
516                 break;
517             }
518 
519             /* invalid code */
520             if (here.op & 64) {
521                 strm->msg = (char *)"invalid literal/length code";
522                 state->mode = BAD;
523                 break;
524             }
525 
526             /* length code -- get extra bits, if any */
527             state->extra = (unsigned)(here.op) & 15;
528             if (state->extra != 0) {
529                 NEEDBITS(state->extra);
530                 state->length += BITS(state->extra);
531                 DROPBITS(state->extra);
532             }
533             Tracevv((stderr, "inflate:         length %u\n", state->length));
534 
535             /* get distance code */
536             for (;;) {
537                 here = state->distcode[BITS(state->distbits)];
538                 if ((unsigned)(here.bits) <= bits) break;
539                 PULLBYTE();
540             }
541             if ((here.op & 0xf0) == 0) {
542                 last = here;
543                 for (;;) {
544                     here = state->distcode[last.val +
545                             (BITS(last.bits + last.op) >> last.bits)];
546                     if ((unsigned)(last.bits + here.bits) <= bits) break;
547                     PULLBYTE();
548                 }
549                 DROPBITS(last.bits);
550             }
551             DROPBITS(here.bits);
552             if (here.op & 64) {
553                 strm->msg = (char *)"invalid distance code";
554                 state->mode = BAD;
555                 break;
556             }
557             state->offset = (unsigned)here.val;
558 
559             /* get distance extra bits, if any */
560             state->extra = (unsigned)(here.op) & 15;
561             if (state->extra != 0) {
562                 NEEDBITS(state->extra);
563                 state->offset += BITS(state->extra);
564                 DROPBITS(state->extra);
565             }
566             if (state->offset > state->wsize - (state->whave < state->wsize ?
567                                                 left : 0)) {
568                 strm->msg = (char *)"invalid distance too far back";
569                 state->mode = BAD;
570                 break;
571             }
572             Tracevv((stderr, "inflate:         distance %u\n", state->offset));
573 
574             /* copy match from window to output */
575             do {
576                 ROOM();
577                 copy = state->wsize - state->offset;
578                 if (copy < left) {
579                     from = put + copy;
580                     copy = left - copy;
581                 }
582                 else {
583                     from = put - state->offset;
584                     copy = left;
585                 }
586                 if (copy > state->length) copy = state->length;
587                 state->length -= copy;
588                 left -= copy;
589                 do {
590                     *put++ = *from++;
591                 } while (--copy);
592             } while (state->length != 0);
593             break;
594 
595         case DONE:
596             /* inflate stream terminated properly */
597             ret = Z_STREAM_END;
598             goto inf_leave;
599 
600         case BAD:
601             ret = Z_DATA_ERROR;
602             goto inf_leave;
603 
604         default:
605             /* can't happen, but makes compilers happy */
606             ret = Z_STREAM_ERROR;
607             goto inf_leave;
608         }
609 
610     /* Write leftover output and return unused input */
611   inf_leave:
612     if (left < state->wsize) {
613         if (out(out_desc, state->window, state->wsize - left) &&
614             ret == Z_STREAM_END)
615             ret = Z_BUF_ERROR;
616     }
617     strm->next_in = next;
618     strm->avail_in = have;
619     return ret;
620 }
621 
inflateBackEnd(z_streamp strm)622 int ZEXPORT inflateBackEnd(z_streamp strm) {
623     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
624         return Z_STREAM_ERROR;
625     ZFREE(strm, strm->state);
626     strm->state = Z_NULL;
627     Tracev((stderr, "inflate: end\n"));
628     return Z_OK;
629 }
630