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
12 struct inflate_codes_state
{int dummy
;}; /* for buggy compilers */
14 /* simplify the use of the inflate_huft type with some defines */
15 #define exop word.what.Exop
16 #define bits word.what.Bits
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};
23 Notes beyond the 1.93a appnote.txt:
25 1. Distance pointers never point before the beginning of the output
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
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.
68 void inflate_blocks_reset(s
, z
, c
)
69 inflate_blocks_statef
*s
;
75 if (s
->mode
== BTREE
|| s
->mode
== DTREE
)
76 ZFREE(z
, s
->sub
.trees
.blens
);
78 inflate_codes_free(s
->sub
.decode
.codes
, z
);
82 s
->read
= s
->write
= s
->window
;
83 if (s
->checkfn
!= Z_NULL
)
84 z
->adler
= s
->check
= (*s
->checkfn
)(0L, (const Bytef
*)Z_NULL
, 0);
85 Tracev((stderr
, "inflate: blocks reset\n"));
89 inflate_blocks_statef
*inflate_blocks_new(z
, c
, w
)
94 inflate_blocks_statef
*s
;
96 if ((s
= (inflate_blocks_statef
*)ZALLOC
97 (z
,1,sizeof(struct inflate_blocks_state
))) == Z_NULL
)
100 (inflate_huft
*)ZALLOC(z
, sizeof(inflate_huft
), MANY
)) == Z_NULL
)
105 if ((s
->window
= (Bytef
*)ZALLOC(z
, 1, w
)) == Z_NULL
)
111 s
->end
= s
->window
+ w
;
114 Tracev((stderr
, "inflate: blocks allocated\n"));
115 inflate_blocks_reset(s
, z
, Z_NULL
);
120 int inflate_blocks(s
, z
, r
)
121 inflate_blocks_statef
*s
;
125 uInt t
; /* temporary storage */
126 uLong b
; /* bit buffer */
127 uInt k
; /* bits in bit buffer */
128 Bytef
*p
; /* input data pointer */
129 uInt n
; /* bytes available there */
130 Bytef
*q
; /* output window write pointer */
131 uInt m
; /* bytes to end of window or read pointer */
133 /* copy input/output information to locals (UPDATE macro restores) */
136 /* process input based on current state */
137 while (1) switch (s
->mode
)
146 Tracev((stderr
, "inflate: stored block%s\n",
147 s
->last
? " (last)" : ""));
149 t
= k
& 7; /* go to byte boundary */
151 s
->mode
= LENS
; /* get length of stored block */
154 Tracev((stderr
, "inflate: fixed codes block%s\n",
155 s
->last
? " (last)" : ""));
158 inflate_huft
*tl
, *td
;
160 inflate_trees_fixed(&bl
, &bd
, &tl
, &td
, z
);
161 s
->sub
.decode
.codes
= inflate_codes_new(bl
, bd
, tl
, td
, z
);
162 if (s
->sub
.decode
.codes
== Z_NULL
)
171 case 2: /* dynamic */
172 Tracev((stderr
, "inflate: dynamic codes block%s\n",
173 s
->last
? " (last)" : ""));
177 case 3: /* illegal */
180 z
->msg
= (char*)"invalid block type";
187 if ((((~b
) >> 16) & 0xffff) != (b
& 0xffff))
190 z
->msg
= (char*)"invalid stored block lengths";
194 s
->sub
.left
= (uInt
)b
& 0xffff;
195 b
= k
= 0; /* dump bits */
196 Tracev((stderr
, "inflate: stored length %u\n", s
->sub
.left
));
197 s
->mode
= s
->sub
.left
? STORED
: (s
->last
? DRY
: TYPE
);
209 if ((s
->sub
.left
-= t
) != 0)
211 Tracev((stderr
, "inflate: stored end, %lu total out\n",
212 z
->total_out
+ (q
>= s
->read
? q
- s
->read
:
213 (s
->end
- s
->read
) + (q
- s
->window
))));
214 s
->mode
= s
->last
? DRY
: TYPE
;
218 s
->sub
.trees
.table
= t
= (uInt
)b
& 0x3fff;
219 #ifndef PKZIP_BUG_WORKAROUND
220 if ((t
& 0x1f) > 29 || ((t
>> 5) & 0x1f) > 29)
223 z
->msg
= (char*)"too many length or distance symbols";
228 t
= 258 + (t
& 0x1f) + ((t
>> 5) & 0x1f);
229 if ((s
->sub
.trees
.blens
= (uIntf
*)ZALLOC(z
, t
, sizeof(uInt
))) == Z_NULL
)
235 s
->sub
.trees
.index
= 0;
236 Tracev((stderr
, "inflate: table sizes ok\n"));
239 while (s
->sub
.trees
.index
< 4 + (s
->sub
.trees
.table
>> 10))
242 s
->sub
.trees
.blens
[border
[s
->sub
.trees
.index
++]] = (uInt
)b
& 7;
245 while (s
->sub
.trees
.index
< 19)
246 s
->sub
.trees
.blens
[border
[s
->sub
.trees
.index
++]] = 0;
248 t
= inflate_trees_bits(s
->sub
.trees
.blens
, &s
->sub
.trees
.bb
,
249 &s
->sub
.trees
.tb
, s
->hufts
, z
);
253 if (r
== Z_DATA_ERROR
)
255 ZFREE(z
, s
->sub
.trees
.blens
);
260 s
->sub
.trees
.index
= 0;
261 Tracev((stderr
, "inflate: bits tree ok\n"));
264 while (t
= s
->sub
.trees
.table
,
265 s
->sub
.trees
.index
< 258 + (t
& 0x1f) + ((t
>> 5) & 0x1f))
272 h
= s
->sub
.trees
.tb
+ ((uInt
)b
& inflate_mask
[t
]);
278 s
->sub
.trees
.blens
[s
->sub
.trees
.index
++] = c
;
280 else /* c == 16..18 */
282 i
= c
== 18 ? 7 : c
- 14;
283 j
= c
== 18 ? 11 : 3;
286 j
+= (uInt
)b
& inflate_mask
[i
];
288 i
= s
->sub
.trees
.index
;
289 t
= s
->sub
.trees
.table
;
290 if (i
+ j
> 258 + (t
& 0x1f) + ((t
>> 5) & 0x1f) ||
293 ZFREE(z
, s
->sub
.trees
.blens
);
295 z
->msg
= (char*)"invalid bit length repeat";
299 c
= c
== 16 ? s
->sub
.trees
.blens
[i
- 1] : 0;
301 s
->sub
.trees
.blens
[i
++] = c
;
303 s
->sub
.trees
.index
= i
;
306 s
->sub
.trees
.tb
= Z_NULL
;
309 inflate_huft
*tl
, *td
;
310 inflate_codes_statef
*c
;
312 bl
= 9; /* must be <= 9 for lookahead assumptions */
313 bd
= 6; /* must be <= 9 for lookahead assumptions */
314 t
= s
->sub
.trees
.table
;
315 t
= inflate_trees_dynamic(257 + (t
& 0x1f), 1 + ((t
>> 5) & 0x1f),
316 s
->sub
.trees
.blens
, &bl
, &bd
, &tl
, &td
,
320 if (t
== (uInt
)Z_DATA_ERROR
)
322 ZFREE(z
, s
->sub
.trees
.blens
);
328 Tracev((stderr
, "inflate: trees ok\n"));
329 if ((c
= inflate_codes_new(bl
, bd
, tl
, td
, z
)) == Z_NULL
)
334 s
->sub
.decode
.codes
= c
;
336 ZFREE(z
, s
->sub
.trees
.blens
);
340 if ((r
= inflate_codes(s
, z
, r
)) != Z_STREAM_END
)
341 return inflate_flush(s
, z
, r
);
343 inflate_codes_free(s
->sub
.decode
.codes
, z
);
345 Tracev((stderr
, "inflate: codes end, %lu total out\n",
346 z
->total_out
+ (q
>= s
->read
? q
- s
->read
:
347 (s
->end
- s
->read
) + (q
- s
->window
))));
356 if (s
->read
!= s
->write
)
372 int inflate_blocks_free(s
, z
)
373 inflate_blocks_statef
*s
;
376 inflate_blocks_reset(s
, z
, Z_NULL
);
380 Tracev((stderr
, "inflate: blocks freed\n"));
385 void inflate_set_dictionary(s
, d
, n
)
386 inflate_blocks_statef
*s
;
390 zmemcpy(s
->window
, d
, n
);
391 s
->read
= s
->write
= s
->window
+ n
;
395 /* Returns true if inflate is currently at the end of a block generated
396 * by Z_SYNC_FLUSH or Z_FULL_FLUSH.
397 * IN assertion: s != Z_NULL
399 int inflate_blocks_sync_point(s
)
400 inflate_blocks_statef
*s
;
402 return s
->mode
== LENS
;