1 /* infblock.c -- interpret and process block types to last block
2 * Copyright (C) 1995-2002 Mark Adler
3 * For conditions of distribution and use, see copyright notice in zlib.h
7 __FBSDID("$FreeBSD: src/lib/libz/infblock.c,v 1.1.1.4.6.2 2003/02/01 13:33:12 sobomax Exp $");
15 struct inflate_codes_state {int dummy;}; /* for buggy compilers */
17 /* simplify the use of the inflate_huft type with some defines */
18 #define exop word.what.Exop
19 #define bits word.what.Bits
21 /* Table for deflate from PKZIP's appnote.txt. */
22 local const uInt border[] = { /* Order of the bit length code lengths */
23 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
26 Notes beyond the 1.93a appnote.txt:
28 1. Distance pointers never point before the beginning of the output
30 2. Distance pointers can point back across blocks, up to 32k away.
31 3. There is an implied maximum of 7 bits for the bit length table and
32 15 bits for the actual data.
33 4. If only one code exists, then it is encoded using one bit. (Zero
34 would be more efficient, but perhaps a little confusing.) If two
35 codes exist, they are coded using one bit each (0 and 1).
36 5. There is no way of sending zero distance codes--a dummy must be
37 sent if there are none. (History: a pre 2.0 version of PKZIP would
38 store blocks with no distance codes, but this was discovered to be
39 too harsh a criterion.) Valid only for 1.93a. 2.04c does allow
40 zero distance codes, which is sent as one code of zero bits in
42 6. There are up to 286 literal/length codes. Code 256 represents the
43 end-of-block. Note however that the static length tree defines
44 288 codes just to fill out the Huffman codes. Codes 286 and 287
45 cannot be used though, since there is no length base or extra bits
46 defined for them. Similarily, there are up to 30 distance codes.
47 However, static trees define 32 codes (all 5 bits) to fill out the
48 Huffman codes, but the last two had better not show up in the data.
49 7. Unzip can check dynamic Huffman blocks for complete code sets.
50 The exception is that a single code would not be complete (see #4).
51 8. The five bits following the block type is really the number of
52 literal codes sent minus 257.
53 9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
54 (1+6+6). Therefore, to output three times the length, you output
55 three codes (1+1+1), whereas to output four times the same length,
56 you only need two codes (1+3). Hmm.
57 10. In the tree reconstruction algorithm, Code = Code + Increment
58 only if BitLength(i) is not zero. (Pretty obvious.)
59 11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19)
60 12. Note: length code 284 can represent 227-258, but length code 285
61 really is 258. The last length deserves its own, short code
62 since it gets used a lot in very redundant files. The length
63 258 is special since 258 - 3 (the min match length) is 255.
64 13. The literal/length and distance code bit lengths are read as a
65 single stream of lengths. It is possible (and advantageous) for
66 a repeat code (16, 17, or 18) to go across the boundary between
67 the two sets of lengths.
71 void inflate_blocks_reset(s, z, c)
72 inflate_blocks_statef *s;
78 if (s->mode == BTREE || s->mode == DTREE)
79 ZFREE(z, s->sub.trees.blens);
81 inflate_codes_free(s->sub.decode.codes, z);
85 s->read = s->write = s->window;
86 if (s->checkfn != Z_NULL)
87 z->adler = s->check = (*s->checkfn)(0L, (const Bytef *)Z_NULL, 0);
88 Tracev((stderr, "inflate: blocks reset\n"));
92 inflate_blocks_statef *inflate_blocks_new(z, c, w)
97 inflate_blocks_statef *s;
99 if ((s = (inflate_blocks_statef *)ZALLOC
100 (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
103 (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL)
108 if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)
114 s->end = s->window + w;
117 Tracev((stderr, "inflate: blocks allocated\n"));
118 inflate_blocks_reset(s, z, Z_NULL);
123 int inflate_blocks(s, z, r)
124 inflate_blocks_statef *s;
128 uInt t; /* temporary storage */
129 uLong b; /* bit buffer */
130 uInt k; /* bits in bit buffer */
131 Bytef *p; /* input data pointer */
132 uInt n; /* bytes available there */
133 Bytef *q; /* output window write pointer */
134 uInt m; /* bytes to end of window or read pointer */
136 /* copy input/output information to locals (UPDATE macro restores) */
139 /* process input based on current state */
140 while (1) switch (s->mode)
149 Tracev((stderr, "inflate: stored block%s\n",
150 s->last ? " (last)" : ""));
152 t = k & 7; /* go to byte boundary */
154 s->mode = LENS; /* get length of stored block */
157 Tracev((stderr, "inflate: fixed codes block%s\n",
158 s->last ? " (last)" : ""));
161 inflate_huft *tl, *td;
163 inflate_trees_fixed(&bl, &bd, &tl, &td, z);
164 s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
165 if (s->sub.decode.codes == Z_NULL)
174 case 2: /* dynamic */
175 Tracev((stderr, "inflate: dynamic codes block%s\n",
176 s->last ? " (last)" : ""));
180 case 3: /* illegal */
183 z->msg = (char*)"invalid block type";
190 if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
193 z->msg = (char*)"invalid stored block lengths";
197 s->sub.left = (uInt)b & 0xffff;
198 b = k = 0; /* dump bits */
199 Tracev((stderr, "inflate: stored length %u\n", s->sub.left));
200 s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE);
212 if ((s->sub.left -= t) != 0)
214 Tracev((stderr, "inflate: stored end, %lu total out\n",
215 z->total_out + (q >= s->read ? q - s->read :
216 (s->end - s->read) + (q - s->window))));
217 s->mode = s->last ? DRY : TYPE;
221 s->sub.trees.table = t = (uInt)b & 0x3fff;
222 #ifndef PKZIP_BUG_WORKAROUND
223 if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
226 z->msg = (char*)"too many length or distance symbols";
231 t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
232 if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
238 s->sub.trees.index = 0;
239 Tracev((stderr, "inflate: table sizes ok\n"));
242 while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
245 s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
248 while (s->sub.trees.index < 19)
249 s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
251 t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
252 &s->sub.trees.tb, s->hufts, z);
256 if (r == Z_DATA_ERROR)
258 ZFREE(z, s->sub.trees.blens);
263 s->sub.trees.index = 0;
264 Tracev((stderr, "inflate: bits tree ok\n"));
267 while (t = s->sub.trees.table,
268 s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
275 h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
281 s->sub.trees.blens[s->sub.trees.index++] = c;
283 else /* c == 16..18 */
285 i = c == 18 ? 7 : c - 14;
286 j = c == 18 ? 11 : 3;
289 j += (uInt)b & inflate_mask[i];
291 i = s->sub.trees.index;
292 t = s->sub.trees.table;
293 if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
296 ZFREE(z, s->sub.trees.blens);
298 z->msg = (char*)"invalid bit length repeat";
302 c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
304 s->sub.trees.blens[i++] = c;
306 s->sub.trees.index = i;
309 s->sub.trees.tb = Z_NULL;
312 inflate_huft *tl, *td;
313 inflate_codes_statef *c;
315 bl = 9; /* must be <= 9 for lookahead assumptions */
316 bd = 6; /* must be <= 9 for lookahead assumptions */
317 t = s->sub.trees.table;
318 t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
319 s->sub.trees.blens, &bl, &bd, &tl, &td,
323 if (t == (uInt)Z_DATA_ERROR)
325 ZFREE(z, s->sub.trees.blens);
331 Tracev((stderr, "inflate: trees ok\n"));
332 if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
337 s->sub.decode.codes = c;
339 ZFREE(z, s->sub.trees.blens);
343 if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
344 return inflate_flush(s, z, r);
346 inflate_codes_free(s->sub.decode.codes, z);
348 Tracev((stderr, "inflate: codes end, %lu total out\n",
349 z->total_out + (q >= s->read ? q - s->read :
350 (s->end - s->read) + (q - s->window))));
359 if (s->read != s->write)
375 int inflate_blocks_free(s, z)
376 inflate_blocks_statef *s;
379 inflate_blocks_reset(s, z, Z_NULL);
383 Tracev((stderr, "inflate: blocks freed\n"));
388 void inflate_set_dictionary(s, d, n)
389 inflate_blocks_statef *s;
393 zmemcpy(s->window, d, n);
394 s->read = s->write = s->window + n;
398 /* Returns true if inflate is currently at the end of a block generated
399 * by Z_SYNC_FLUSH or Z_FULL_FLUSH.
400 * IN assertion: s != Z_NULL
402 int inflate_blocks_sync_point(s)
403 inflate_blocks_statef *s;
405 return s->mode == LENS;