1 /* infback.c -- inflate using a call-back interface
2 * Copyright (C) 1995-2003 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.
18 /* function prototypes */
19 local void fixedtables OF((struct inflate_state FAR *state));
22 strm provides memory allocation functions in zalloc and zfree, or
23 Z_NULL to use the library memory allocation functions.
25 windowBits is in the range 8..15, and window is a user-supplied
26 window and output buffer that is 2**windowBits bytes.
28 int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
31 unsigned char FAR *window;
35 struct inflate_state FAR *state;
37 if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
38 stream_size != (int)(sizeof(z_stream)))
39 return Z_VERSION_ERROR;
40 if (strm == Z_NULL || window == Z_NULL ||
41 windowBits < 8 || windowBits > 15)
42 return Z_STREAM_ERROR;
43 strm->msg = Z_NULL; /* in case we return an error */
44 if (strm->zalloc == Z_NULL) {
45 strm->zalloc = zcalloc;
46 strm->opaque = (voidpf)0;
48 if (strm->zfree == Z_NULL) strm->zfree = zcfree;
49 state = (struct inflate_state FAR *)ZALLOC(strm, 1,
50 sizeof(struct inflate_state));
51 if (state == Z_NULL) return Z_MEM_ERROR;
52 Tracev((stderr, "inflate: allocated\n"));
53 strm->state = (voidpf)state;
54 state->wbits = windowBits;
55 state->wsize = 1U << windowBits;
56 state->window = window;
62 Return state with length and distance decoding tables and index sizes set to
63 fixed code decoding. Normally this returns fixed tables from inffixed.h.
64 If BUILDFIXED is defined, then instead this routine builds the tables the
65 first time it's called, and returns those tables the first time and
66 thereafter. This reduces the size of the code by about 2K bytes, in
67 exchange for a little execution time. However, BUILDFIXED should not be
68 used for threaded applications, since the rewriting of the tables and virgin
69 may not be thread-safe.
71 local void fixedtables(state)
72 struct inflate_state FAR *state;
75 static int virgin = 1;
76 static code *lenfix, *distfix;
77 static code fixed[544];
79 /* build fixed huffman tables if first call (may not be thread safe) */
84 /* literal/length table */
86 while (sym < 144) state->lens[sym++] = 8;
87 while (sym < 256) state->lens[sym++] = 9;
88 while (sym < 280) state->lens[sym++] = 7;
89 while (sym < 288) state->lens[sym++] = 8;
93 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
97 while (sym < 32) state->lens[sym++] = 5;
100 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
102 /* do this just once */
105 #else /* !BUILDFIXED */
106 # include "inffixed.h"
107 #endif /* BUILDFIXED */
108 state->lencode = lenfix;
110 state->distcode = distfix;
114 /* Macros for inflateBack(): */
116 /* Load returned state from inflate_fast() */
119 put = strm->next_out; \
120 left = strm->avail_out; \
121 next = strm->next_in; \
122 have = strm->avail_in; \
123 hold = state->hold; \
124 bits = state->bits; \
127 /* Set state from registers for inflate_fast() */
130 strm->next_out = put; \
131 strm->avail_out = left; \
132 strm->next_in = next; \
133 strm->avail_in = have; \
134 state->hold = hold; \
135 state->bits = bits; \
138 /* Clear the input bit accumulator */
145 /* Assure that some input is available. If input is requested, but denied,
146 then return a Z_BUF_ERROR from inflateBack(). */
150 have = in(in_desc, &next); \
159 /* Get a byte of input into the bit accumulator, or return from inflateBack()
160 with an error if there is no input available. */
165 hold += (unsigned long)(*next++) << bits; \
169 /* Assure that there are at least n bits in the bit accumulator. If there is
170 not enough available input to do that, then return from inflateBack() with
172 #define NEEDBITS(n) \
174 while (bits < (unsigned)(n)) \
178 /* Return the low n bits of the bit accumulator (n < 16) */
180 ((unsigned)hold & ((1U << (n)) - 1))
182 /* Remove n bits from the bit accumulator */
183 #define DROPBITS(n) \
186 bits -= (unsigned)(n); \
189 /* Remove zero to seven bits as needed to go to a byte boundary */
196 /* Assure that some output space is available, by writing out the window
197 if it's full. If the write fails, return from inflateBack() with a
202 put = state->window; \
203 left = state->wsize; \
204 if (out(out_desc, put, left)) { \
212 strm provides the memory allocation functions and window buffer on input,
213 and provides information on the unused input on return. For Z_DATA_ERROR
214 returns, strm will also provide an error message.
216 in() and out() are the call-back input and output functions. When
217 inflateBack() needs more input, it calls in(). When inflateBack() has
218 filled the window with output, or when it completes with data in the
219 window, it called out() to write out the data. The application must not
220 change the provided input until in() is called again or inflateBack()
221 returns. The application must not change the window/output buffer until
222 inflateBack() returns.
224 in() and out() are called with a descriptor parameter provided in the
225 inflateBack() call. This parameter can be a structure that provides the
226 information required to do the read or write, as well as accumulated
227 information on the input and output such as totals and check values.
229 in() should return zero on failure. out() should return non-zero on
230 failure. If either in() or out() fails, than inflateBack() returns a
231 Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
232 was in() or out() that caused in the error. Otherwise, inflateBack()
233 returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
234 error, or Z_MEM_ERROR if it could not allocate memory for the state.
235 inflateBack() can also return Z_STREAM_ERROR if the input parameters
236 are not correct, i.e. strm is Z_NULL or the state was not initialized.
238 int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
245 struct inflate_state FAR *state;
246 unsigned char *next, *put; /* next input and 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 *from; /* where to copy match bytes from */
252 code this; /* 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 */
268 next = strm->next_in;
269 have = next != Z_NULL ? strm->avail_in : 0;
275 /* Inflate until end of block marked as last */
277 switch (state->mode) {
279 /* determine and dispatch block type */
286 state->last = BITS(1);
289 case 0: /* stored block */
290 Tracev((stderr, "inflate: stored block%s\n",
291 state->last ? " (last)" : ""));
292 state->mode = STORED;
294 case 1: /* fixed block */
296 Tracev((stderr, "inflate: fixed codes block%s\n",
297 state->last ? " (last)" : ""));
298 state->mode = LEN; /* decode codes */
300 case 2: /* dynamic block */
301 Tracev((stderr, "inflate: dynamic codes block%s\n",
302 state->last ? " (last)" : ""));
306 strm->msg = (char *)"invalid block type";
313 /* get and verify stored block length */
314 BYTEBITS(); /* go to byte boundary */
316 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
317 strm->msg = (char *)"invalid stored block lengths";
321 state->length = (unsigned)hold & 0xffff;
322 Tracev((stderr, "inflate: stored length %u\n",
326 /* copy stored block from input to output */
327 while (state->length != 0) {
328 copy = state->length;
331 if (copy > have) copy = have;
332 if (copy > left) copy = left;
333 zmemcpy(put, next, copy);
338 state->length -= copy;
340 Tracev((stderr, "inflate: stored end\n"));
345 /* get dynamic table entries descriptor */
347 state->nlen = BITS(5) + 257;
349 state->ndist = BITS(5) + 1;
351 state->ncode = BITS(4) + 4;
353 #ifndef PKZIP_BUG_WORKAROUND
354 if (state->nlen > 286 || state->ndist > 30) {
355 strm->msg = (char *)"too many length or distance symbols";
360 Tracev((stderr, "inflate: table sizes ok\n"));
362 /* get code length code lengths (not a typo) */
364 while (state->have < state->ncode) {
366 state->lens[order[state->have++]] = (unsigned short)BITS(3);
369 while (state->have < 19)
370 state->lens[order[state->have++]] = 0;
371 state->next = state->codes;
372 state->lencode = (code const FAR *)(state->next);
374 ret = inflate_table(CODES, state->lens, 19, &(state->next),
375 &(state->lenbits), state->work);
377 strm->msg = (char *)"invalid code lengths set";
381 Tracev((stderr, "inflate: code lengths ok\n"));
383 /* get length and distance code code lengths */
385 while (state->have < state->nlen + state->ndist) {
387 this = state->lencode[BITS(state->lenbits)];
388 if ((unsigned)(this.bits) <= bits) break;
394 state->lens[state->have++] = this.val;
397 if (this.val == 16) {
398 NEEDBITS(this.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 (this.val == 17) {
410 NEEDBITS(this.bits + 3);
417 NEEDBITS(this.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 /* build code tables */
434 state->next = state->codes;
435 state->lencode = (code const FAR *)(state->next);
437 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
438 &(state->lenbits), state->work);
440 strm->msg = (char *)"invalid literal/lengths set";
444 state->distcode = (code const FAR *)(state->next);
446 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
447 &(state->next), &(state->distbits), state->work);
449 strm->msg = (char *)"invalid distances set";
453 Tracev((stderr, "inflate: codes ok\n"));
457 /* use inflate_fast() if we have enough input and output */
458 if (have >= 6 && left >= 258) {
460 inflate_fast(strm, state->wsize);
465 /* get a literal, length, or end-of-block code */
467 this = state->lencode[BITS(state->lenbits)];
468 if ((unsigned)(this.bits) <= bits) break;
471 if (this.op && (this.op & 0xf0) == 0) {
474 this = state->lencode[last.val +
475 (BITS(last.bits + last.op) >> last.bits)];
476 if ((unsigned)(last.bits + this.bits) <= bits) break;
482 state->length = (unsigned)this.val;
484 /* process literal */
486 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
487 "inflate: literal '%c'\n" :
488 "inflate: literal 0x%02x\n", this.val));
490 *put++ = (unsigned char)(state->length);
496 /* process end of block */
498 Tracevv((stderr, "inflate: end of block\n"));
505 strm->msg = (char *)"invalid literal/length code";
510 /* length code -- get extra bits, if any */
511 state->extra = (unsigned)(this.op) & 15;
512 if (state->extra != 0) {
513 NEEDBITS(state->extra);
514 state->length += BITS(state->extra);
515 DROPBITS(state->extra);
517 Tracevv((stderr, "inflate: length %u\n", state->length));
519 /* get distance code */
521 this = state->distcode[BITS(state->distbits)];
522 if ((unsigned)(this.bits) <= bits) break;
525 if ((this.op & 0xf0) == 0) {
528 this = state->distcode[last.val +
529 (BITS(last.bits + last.op) >> last.bits)];
530 if ((unsigned)(last.bits + this.bits) <= bits) break;
537 strm->msg = (char *)"invalid distance code";
541 state->offset = (unsigned)this.val;
543 /* get distance extra bits, if any */
544 state->extra = (unsigned)(this.op) & 15;
545 if (state->extra != 0) {
546 NEEDBITS(state->extra);
547 state->offset += BITS(state->extra);
548 DROPBITS(state->extra);
550 if (state->offset > state->wsize) {
551 strm->msg = (char *)"invalid distance too far back";
555 Tracevv((stderr, "inflate: distance %u\n", state->offset));
557 /* copy match from window to output */
560 copy = state->wsize - state->offset;
566 from = put - state->offset;
569 if (copy > state->length) copy = state->length;
570 state->length -= copy;
575 } while (state->length != 0);
579 /* inflate stream terminated properly -- write leftover output */
581 if (left < state->wsize) {
582 if (out(out_desc, state->window, state->wsize - left))
591 default: /* can't happen, but makes compilers happy */
592 ret = Z_STREAM_ERROR;
596 /* Return unused input */
598 strm->next_in = next;
599 strm->avail_in = have;
603 int ZEXPORT inflateBackEnd(strm)
606 struct inflate_state FAR *state;
608 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == Z_NULL)
609 return Z_STREAM_ERROR;
610 state = (struct inflate_state FAR *)strm->state;
611 ZFREE(strm, strm->state);
612 strm->state = Z_NULL;
613 Tracev((stderr, "inflate: end\n"));