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