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
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.
19 strm provides memory allocation functions in zalloc and zfree, or
20 Z_NULL to use the library memory allocation functions.
22 windowBits is in the range 8..15, and window is a user-supplied
23 window and output buffer that is 2**windowBits bytes.
25 int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits,
26 unsigned char FAR *window, const char *version,
28 struct inflate_state FAR *state;
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) {
39 return Z_STREAM_ERROR;
41 strm->zalloc = zcalloc;
42 strm->opaque = (voidpf)0;
45 if (strm->zfree == (free_func)0)
47 return Z_STREAM_ERROR;
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;
57 state->wbits = (uInt)windowBits;
58 state->wsize = 1U << windowBits;
59 state->window = window;
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.
76 local void fixedtables(struct inflate_state FAR *state) {
78 static int virgin = 1;
79 static code *lenfix, *distfix;
80 static code fixed[544];
82 /* build fixed huffman tables if first call (may not be thread safe) */
87 /* literal/length table */
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;
96 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
100 while (sym < 32) state->lens[sym++] = 5;
103 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
105 /* do this just once */
108 #else /* !BUILDFIXED */
109 # include "inffixed.h"
110 #endif /* BUILDFIXED */
111 state->lencode = lenfix;
113 state->distcode = distfix;
117 /* Macros for inflateBack(): */
119 /* Load returned state from inflate_fast() */
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; \
130 /* Set state from registers for inflate_fast() */
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; \
141 /* Clear the input bit accumulator */
148 /* Assure that some input is available. If input is requested, but denied,
149 then return a Z_BUF_ERROR from inflateBack(). */
153 have = in(in_desc, &next); \
162 /* Get a byte of input into the bit accumulator, or return from inflateBack()
163 with an error if there is no input available. */
168 hold += (unsigned long)(*next++) << bits; \
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
175 #define NEEDBITS(n) \
177 while (bits < (unsigned)(n)) \
181 /* Return the low n bits of the bit accumulator (n < 16) */
183 ((unsigned)hold & ((1U << (n)) - 1))
185 /* Remove n bits from the bit accumulator */
186 #define DROPBITS(n) \
189 bits -= (unsigned)(n); \
192 /* Remove zero to seven bits as needed to go to a byte boundary */
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
205 put = state->window; \
206 left = state->wsize; \
207 state->whave = left; \
208 if (out(out_desc, put, left)) { \
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.
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.
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.
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.
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};
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;
264 /* Reset the state */
269 next = strm->next_in;
270 have = next != Z_NULL ? strm->avail_in : 0;
276 /* Inflate until end of block marked as last */
278 switch (state->mode) {
280 /* determine and dispatch block type */
287 state->last = BITS(1);
290 case 0: /* stored block */
291 Tracev((stderr, "inflate: stored block%s\n",
292 state->last ? " (last)" : ""));
293 state->mode = STORED;
295 case 1: /* fixed block */
297 Tracev((stderr, "inflate: fixed codes block%s\n",
298 state->last ? " (last)" : ""));
299 state->mode = LEN; /* decode codes */
301 case 2: /* dynamic block */
302 Tracev((stderr, "inflate: dynamic codes block%s\n",
303 state->last ? " (last)" : ""));
307 strm->msg = (char *)"invalid block type";
314 /* get and verify stored block length */
315 BYTEBITS(); /* go to byte boundary */
317 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
318 strm->msg = (char *)"invalid stored block lengths";
322 state->length = (unsigned)hold & 0xffff;
323 Tracev((stderr, "inflate: stored length %u\n",
327 /* copy stored block from input to output */
328 while (state->length != 0) {
329 copy = state->length;
332 if (copy > have) copy = have;
333 if (copy > left) copy = left;
334 zmemcpy(put, next, copy);
339 state->length -= copy;
341 Tracev((stderr, "inflate: stored end\n"));
346 /* get dynamic table entries descriptor */
348 state->nlen = BITS(5) + 257;
350 state->ndist = BITS(5) + 1;
352 state->ncode = BITS(4) + 4;
354 #ifndef PKZIP_BUG_WORKAROUND
355 if (state->nlen > 286 || state->ndist > 30) {
356 strm->msg = (char *)"too many length or distance symbols";
361 Tracev((stderr, "inflate: table sizes ok\n"));
363 /* get code length code lengths (not a typo) */
365 while (state->have < state->ncode) {
367 state->lens[order[state->have++]] = (unsigned short)BITS(3);
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);
375 ret = inflate_table(CODES, state->lens, 19, &(state->next),
376 &(state->lenbits), state->work);
378 strm->msg = (char *)"invalid code lengths set";
382 Tracev((stderr, "inflate: code lengths ok\n"));
384 /* get length and distance code code lengths */
386 while (state->have < state->nlen + state->ndist) {
388 here = state->lencode[BITS(state->lenbits)];
389 if ((unsigned)(here.bits) <= bits) break;
394 state->lens[state->have++] = here.val;
397 if (here.val == 16) {
398 NEEDBITS(here.bits + 2);
400 if (state->have == 0) {
401 strm->msg = (char *)"invalid bit length repeat";
405 len = (unsigned)(state->lens[state->have - 1]);
409 else if (here.val == 17) {
410 NEEDBITS(here.bits + 3);
417 NEEDBITS(here.bits + 7);
423 if (state->have + copy > state->nlen + state->ndist) {
424 strm->msg = (char *)"invalid bit length repeat";
429 state->lens[state->have++] = (unsigned short)len;
433 /* handle error breaks in while */
434 if (state->mode == BAD) break;
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";
443 /* build code tables -- note: do not change the lenbits or distbits
444 values here (9 and 6) 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);
449 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
450 &(state->lenbits), state->work);
452 strm->msg = (char *)"invalid literal/lengths set";
456 state->distcode = (code const FAR *)(state->next);
458 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
459 &(state->next), &(state->distbits), state->work);
461 strm->msg = (char *)"invalid distances set";
465 Tracev((stderr, "inflate: codes ok\n"));
470 /* use inflate_fast() if we have enough input and output */
471 if (have >= 6 && left >= 258) {
473 if (state->whave < state->wsize)
474 state->whave = state->wsize - left;
475 inflate_fast(strm, state->wsize);
480 /* get a literal, length, or end-of-block code */
482 here = state->lencode[BITS(state->lenbits)];
483 if ((unsigned)(here.bits) <= bits) break;
486 if (here.op && (here.op & 0xf0) == 0) {
489 here = state->lencode[last.val +
490 (BITS(last.bits + last.op) >> last.bits)];
491 if ((unsigned)(last.bits + here.bits) <= bits) break;
497 state->length = (unsigned)here.val;
499 /* process literal */
501 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
502 "inflate: literal '%c'\n" :
503 "inflate: literal 0x%02x\n", here.val));
505 *put++ = (unsigned char)(state->length);
511 /* process end of block */
513 Tracevv((stderr, "inflate: end of block\n"));
520 strm->msg = (char *)"invalid literal/length code";
525 /* length code -- get extra bits, if any */
526 state->extra = (unsigned)(here.op) & 15;
527 if (state->extra != 0) {
528 NEEDBITS(state->extra);
529 state->length += BITS(state->extra);
530 DROPBITS(state->extra);
532 Tracevv((stderr, "inflate: length %u\n", state->length));
534 /* get distance code */
536 here = state->distcode[BITS(state->distbits)];
537 if ((unsigned)(here.bits) <= bits) break;
540 if ((here.op & 0xf0) == 0) {
543 here = state->distcode[last.val +
544 (BITS(last.bits + last.op) >> last.bits)];
545 if ((unsigned)(last.bits + here.bits) <= bits) break;
552 strm->msg = (char *)"invalid distance code";
556 state->offset = (unsigned)here.val;
558 /* get distance extra bits, if any */
559 state->extra = (unsigned)(here.op) & 15;
560 if (state->extra != 0) {
561 NEEDBITS(state->extra);
562 state->offset += BITS(state->extra);
563 DROPBITS(state->extra);
565 if (state->offset > state->wsize - (state->whave < state->wsize ?
567 strm->msg = (char *)"invalid distance too far back";
571 Tracevv((stderr, "inflate: distance %u\n", state->offset));
573 /* copy match from window to output */
576 copy = state->wsize - state->offset;
582 from = put - state->offset;
585 if (copy > state->length) copy = state->length;
586 state->length -= copy;
591 } while (state->length != 0);
595 /* inflate stream terminated properly */
604 /* can't happen, but makes compilers happy */
605 ret = Z_STREAM_ERROR;
609 /* Write leftover output and return unused input */
611 if (left < state->wsize) {
612 if (out(out_desc, state->window, state->wsize - left) &&
616 strm->next_in = next;
617 strm->avail_in = have;
621 int ZEXPORT inflateBackEnd(z_streamp strm) {
622 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
623 return Z_STREAM_ERROR;
624 ZFREE(strm, strm->state);
625 strm->state = Z_NULL;
626 Tracev((stderr, "inflate: end\n"));