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