1 /* infblock.c -- interpret and process block types to last block
2 * Copyright (C) 1995-1998 Mark Adler
3 * For conditions of distribution and use, see copyright notice in zlib.h
4 */
5
6 #include <linux/zutil.h>
7 #include "infblock.h"
8 #include "inftrees.h"
9 #include "infcodes.h"
10 #include "infutil.h"
11
12 struct inflate_codes_state;
13
14 /* simplify the use of the inflate_huft type with some defines */
15 #define exop word.what.Exop
16 #define bits word.what.Bits
17
18 /* Table for deflate from PKZIP's appnote.txt. */
19 local const uInt border[] = { /* Order of the bit length code lengths */
20 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
21
22 /*
23 Notes beyond the 1.93a appnote.txt:
24
25 1. Distance pointers never point before the beginning of the output
26 stream.
27 2. Distance pointers can point back across blocks, up to 32k away.
28 3. There is an implied maximum of 7 bits for the bit length table and
29 15 bits for the actual data.
30 4. If only one code exists, then it is encoded using one bit. (Zero
31 would be more efficient, but perhaps a little confusing.) If two
32 codes exist, they are coded using one bit each (0 and 1).
33 5. There is no way of sending zero distance codes--a dummy must be
34 sent if there are none. (History: a pre 2.0 version of PKZIP would
35 store blocks with no distance codes, but this was discovered to be
36 too harsh a criterion.) Valid only for 1.93a. 2.04c does allow
37 zero distance codes, which is sent as one code of zero bits in
38 length.
39 6. There are up to 286 literal/length codes. Code 256 represents the
40 end-of-block. Note however that the static length tree defines
41 288 codes just to fill out the Huffman codes. Codes 286 and 287
42 cannot be used though, since there is no length base or extra bits
43 defined for them. Similarily, there are up to 30 distance codes.
44 However, static trees define 32 codes (all 5 bits) to fill out the
45 Huffman codes, but the last two had better not show up in the data.
46 7. Unzip can check dynamic Huffman blocks for complete code sets.
47 The exception is that a single code would not be complete (see #4).
48 8. The five bits following the block type is really the number of
49 literal codes sent minus 257.
50 9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
51 (1+6+6). Therefore, to output three times the length, you output
52 three codes (1+1+1), whereas to output four times the same length,
53 you only need two codes (1+3). Hmm.
54 10. In the tree reconstruction algorithm, Code = Code + Increment
55 only if BitLength(i) is not zero. (Pretty obvious.)
56 11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19)
57 12. Note: length code 284 can represent 227-258, but length code 285
58 really is 258. The last length deserves its own, short code
59 since it gets used a lot in very redundant files. The length
60 258 is special since 258 - 3 (the min match length) is 255.
61 13. The literal/length and distance code bit lengths are read as a
62 single stream of lengths. It is possible (and advantageous) for
63 a repeat code (16, 17, or 18) to go across the boundary between
64 the two sets of lengths.
65 */
66
67
zlib_inflate_blocks_reset(s,z,c)68 void zlib_inflate_blocks_reset(s, z, c)
69 inflate_blocks_statef *s;
70 z_streamp z;
71 uLongf *c;
72 {
73 if (c != Z_NULL)
74 *c = s->check;
75 if (s->mode == CODES)
76 zlib_inflate_codes_free(s->sub.decode.codes, z);
77 s->mode = TYPE;
78 s->bitk = 0;
79 s->bitb = 0;
80 s->read = s->write = s->window;
81 if (s->checkfn != Z_NULL)
82 z->adler = s->check = (*s->checkfn)(0L, (const Bytef *)Z_NULL, 0);
83 }
84
zlib_inflate_blocks_new(z,c,w)85 inflate_blocks_statef *zlib_inflate_blocks_new(z, c, w)
86 z_streamp z;
87 check_func c;
88 uInt w;
89 {
90 inflate_blocks_statef *s;
91
92 s = &WS(z)->working_blocks_state;
93 s->hufts = WS(z)->working_hufts;
94 s->window = WS(z)->working_window;
95 s->end = s->window + w;
96 s->checkfn = c;
97 s->mode = TYPE;
98 zlib_inflate_blocks_reset(s, z, Z_NULL);
99 return s;
100 }
101
102
zlib_inflate_blocks(s,z,r)103 int zlib_inflate_blocks(s, z, r)
104 inflate_blocks_statef *s;
105 z_streamp z;
106 int r;
107 {
108 uInt t; /* temporary storage */
109 uLong b; /* bit buffer */
110 uInt k; /* bits in bit buffer */
111 Bytef *p; /* input data pointer */
112 uInt n; /* bytes available there */
113 Bytef *q; /* output window write pointer */
114 uInt m; /* bytes to end of window or read pointer */
115
116 /* copy input/output information to locals (UPDATE macro restores) */
117 LOAD
118
119 /* process input based on current state */
120 while (1) switch (s->mode)
121 {
122 case TYPE:
123 NEEDBITS(3)
124 t = (uInt)b & 7;
125 s->last = t & 1;
126 switch (t >> 1)
127 {
128 case 0: /* stored */
129 DUMPBITS(3)
130 t = k & 7; /* go to byte boundary */
131 DUMPBITS(t)
132 s->mode = LENS; /* get length of stored block */
133 break;
134 case 1: /* fixed */
135 {
136 uInt bl, bd;
137 inflate_huft *tl, *td;
138
139 zlib_inflate_trees_fixed(&bl, &bd, &tl, &td, z);
140 s->sub.decode.codes = zlib_inflate_codes_new(bl, bd, tl, td, z);
141 if (s->sub.decode.codes == Z_NULL)
142 {
143 r = Z_MEM_ERROR;
144 LEAVE
145 }
146 }
147 DUMPBITS(3)
148 s->mode = CODES;
149 break;
150 case 2: /* dynamic */
151 DUMPBITS(3)
152 s->mode = TABLE;
153 break;
154 case 3: /* illegal */
155 DUMPBITS(3)
156 s->mode = B_BAD;
157 z->msg = (char*)"invalid block type";
158 r = Z_DATA_ERROR;
159 LEAVE
160 }
161 break;
162 case LENS:
163 NEEDBITS(32)
164 if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
165 {
166 s->mode = B_BAD;
167 z->msg = (char*)"invalid stored block lengths";
168 r = Z_DATA_ERROR;
169 LEAVE
170 }
171 s->sub.left = (uInt)b & 0xffff;
172 b = k = 0; /* dump bits */
173 s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE);
174 break;
175 case STORED:
176 if (n == 0)
177 LEAVE
178 NEEDOUT
179 t = s->sub.left;
180 if (t > n) t = n;
181 if (t > m) t = m;
182 memcpy(q, p, t);
183 p += t; n -= t;
184 q += t; m -= t;
185 if ((s->sub.left -= t) != 0)
186 break;
187 s->mode = s->last ? DRY : TYPE;
188 break;
189 case TABLE:
190 NEEDBITS(14)
191 s->sub.trees.table = t = (uInt)b & 0x3fff;
192 #ifndef PKZIP_BUG_WORKAROUND
193 if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
194 {
195 s->mode = B_BAD;
196 z->msg = (char*)"too many length or distance symbols";
197 r = Z_DATA_ERROR;
198 LEAVE
199 }
200 #endif
201 {
202 s->sub.trees.blens = WS(z)->working_blens;
203 }
204 DUMPBITS(14)
205 s->sub.trees.index = 0;
206 s->mode = BTREE;
207 case BTREE:
208 while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
209 {
210 NEEDBITS(3)
211 s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
212 DUMPBITS(3)
213 }
214 while (s->sub.trees.index < 19)
215 s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
216 s->sub.trees.bb = 7;
217 t = zlib_inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
218 &s->sub.trees.tb, s->hufts, z);
219 if (t != Z_OK)
220 {
221 r = t;
222 if (r == Z_DATA_ERROR)
223 s->mode = B_BAD;
224 LEAVE
225 }
226 s->sub.trees.index = 0;
227 s->mode = DTREE;
228 case DTREE:
229 while (t = s->sub.trees.table,
230 s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
231 {
232 inflate_huft *h;
233 uInt i, j, c;
234
235 t = s->sub.trees.bb;
236 NEEDBITS(t)
237 h = s->sub.trees.tb + ((uInt)b & zlib_inflate_mask[t]);
238 t = h->bits;
239 c = h->base;
240 if (c < 16)
241 {
242 DUMPBITS(t)
243 s->sub.trees.blens[s->sub.trees.index++] = c;
244 }
245 else /* c == 16..18 */
246 {
247 i = c == 18 ? 7 : c - 14;
248 j = c == 18 ? 11 : 3;
249 NEEDBITS(t + i)
250 DUMPBITS(t)
251 j += (uInt)b & zlib_inflate_mask[i];
252 DUMPBITS(i)
253 i = s->sub.trees.index;
254 t = s->sub.trees.table;
255 if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
256 (c == 16 && i < 1))
257 {
258 s->mode = B_BAD;
259 z->msg = (char*)"invalid bit length repeat";
260 r = Z_DATA_ERROR;
261 LEAVE
262 }
263 c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
264 do {
265 s->sub.trees.blens[i++] = c;
266 } while (--j);
267 s->sub.trees.index = i;
268 }
269 }
270 s->sub.trees.tb = Z_NULL;
271 {
272 uInt bl, bd;
273 inflate_huft *tl, *td;
274 inflate_codes_statef *c;
275
276 bl = 9; /* must be <= 9 for lookahead assumptions */
277 bd = 6; /* must be <= 9 for lookahead assumptions */
278 t = s->sub.trees.table;
279 t = zlib_inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
280 s->sub.trees.blens, &bl, &bd, &tl, &td,
281 s->hufts, z);
282 if (t != Z_OK)
283 {
284 if (t == (uInt)Z_DATA_ERROR)
285 s->mode = B_BAD;
286 r = t;
287 LEAVE
288 }
289 if ((c = zlib_inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
290 {
291 r = Z_MEM_ERROR;
292 LEAVE
293 }
294 s->sub.decode.codes = c;
295 }
296 s->mode = CODES;
297 case CODES:
298 UPDATE
299 if ((r = zlib_inflate_codes(s, z, r)) != Z_STREAM_END)
300 return zlib_inflate_flush(s, z, r);
301 r = Z_OK;
302 zlib_inflate_codes_free(s->sub.decode.codes, z);
303 LOAD
304 if (!s->last)
305 {
306 s->mode = TYPE;
307 break;
308 }
309 s->mode = DRY;
310 case DRY:
311 FLUSH
312 if (s->read != s->write)
313 LEAVE
314 s->mode = B_DONE;
315 case B_DONE:
316 r = Z_STREAM_END;
317 LEAVE
318 case B_BAD:
319 r = Z_DATA_ERROR;
320 LEAVE
321 default:
322 r = Z_STREAM_ERROR;
323 LEAVE
324 }
325 }
326
327
zlib_inflate_blocks_free(s,z)328 int zlib_inflate_blocks_free(s, z)
329 inflate_blocks_statef *s;
330 z_streamp z;
331 {
332 zlib_inflate_blocks_reset(s, z, Z_NULL);
333 return Z_OK;
334 }
335
336
zlib_inflate_set_dictionary(s,d,n)337 void zlib_inflate_set_dictionary(s, d, n)
338 inflate_blocks_statef *s;
339 const Bytef *d;
340 uInt n;
341 {
342 memcpy(s->window, d, n);
343 s->read = s->write = s->window + n;
344 }
345
346
347 /* Returns true if inflate is currently at the end of a block generated
348 * by Z_SYNC_FLUSH or Z_FULL_FLUSH.
349 * IN assertion: s != Z_NULL
350 */
zlib_inflate_blocks_sync_point(s)351 int zlib_inflate_blocks_sync_point(s)
352 inflate_blocks_statef *s;
353 {
354 return s->mode == LENS;
355 }
356