src/zlib/infblock.c

   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 "zutil.h"
   7 #include "infblock.h"
   8 #include "inftrees.h"
   9 #include "infcodes.h"
  10 #include "infutil.h"
  11
  12 struct inflate_codes_state {int dummy;}; /* for buggy compilers */
  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
  68 void 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 == BTREE || s->mode == DTREE)
  76     ZFREE(z, s->sub.trees.blens);
  77   if (s->mode == CODES)
  78     inflate_codes_free(s->sub.decode.codes, z);
  79   s->mode = TYPE;
  80   s->bitk = 0;
  81   s->bitb = 0;
  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"));
  86 }
  87
  88
  89 inflate_blocks_statef *inflate_blocks_new(z, c, w)
  90 z_streamp z;
  91 check_func c;
  92 uInt w;
  93 {
  94   inflate_blocks_statef *s;
  95
  96   if ((s = (inflate_blocks_statef *)ZALLOC
  97        (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
  98     return s;
  99   if ((s->hufts =
 100        (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL)
 101   {
 102     ZFREE(z, s);
 103     return Z_NULL;
 104   }
 105   if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)
 106   {
 107     ZFREE(z, s->hufts);
 108     ZFREE(z, s);
 109     return Z_NULL;
 110   }
 111   s->end = s->window + w;
 112   s->checkfn = c;
 113   s->mode = TYPE;
 114   Tracev((stderr, "inflate:   blocks allocated\n"));
 115   inflate_blocks_reset(s, z, Z_NULL);
 116   return s;
 117 }
 118
 119
 120 int inflate_blocks(s, z, r)
 121 inflate_blocks_statef *s;
 122 z_streamp z;
 123 int r;
 124 {
 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 */
 132
 133   /* copy input/output information to locals (UPDATE macro restores) */
 134   LOAD
 135
 136   /* process input based on current state */
 137   while (1) switch (s->mode)
 138   {
 139     case TYPE:
 140       NEEDBITS(3)
 141       t = (uInt)b & 7;
 142       s->last = t & 1;
 143       switch (t >> 1)
 144       {
 145         case 0:                         /* stored */
 146           Tracev((stderr, "inflate:     stored block%s\n",
 147                  s->last ? " (last)" : ""));
 148           DUMPBITS(3)
 149           t = k & 7;                    /* go to byte boundary */
 150           DUMPBITS(t)
 151           s->mode = LENS;               /* get length of stored block */
 152           break;
 153         case 1:                         /* fixed */
 154           Tracev((stderr, "inflate:     fixed codes block%s\n",
 155                  s->last ? " (last)" : ""));
 156           {
 157             uInt bl, bd;
 158             inflate_huft *tl, *td;
 159
 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)
 163             {
 164               r = Z_MEM_ERROR;
 165               LEAVE
 166             }
 167           }
 168           DUMPBITS(3)
 169           s->mode = CODES;
 170           break;
 171         case 2:                         /* dynamic */
 172           Tracev((stderr, "inflate:     dynamic codes block%s\n",
 173                  s->last ? " (last)" : ""));
 174           DUMPBITS(3)
 175           s->mode = TABLE;
 176           break;
 177         case 3:                         /* illegal */
 178           DUMPBITS(3)
 179           s->mode = BAD;
 180           z->msg = (char*)"invalid block type";
 181           r = Z_DATA_ERROR;
 182           LEAVE
 183       }
 184       break;
 185     case LENS:
 186       NEEDBITS(32)
 187       if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
 188       {
 189         s->mode = BAD;
 190         z->msg = (char*)"invalid stored block lengths";
 191         r = Z_DATA_ERROR;
 192         LEAVE
 193       }
 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);
 198       break;
 199     case STORED:
 200       if (n == 0)
 201         LEAVE
 202       NEEDOUT
 203       t = s->sub.left;
 204       if (t > n) t = n;
 205       if (t > m) t = m;
 206       zmemcpy(q, p, t);
 207       p += t;  n -= t;
 208       q += t;  m -= t;
 209       if ((s->sub.left -= t) != 0)
 210         break;
 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;
 215       break;
 216     case TABLE:
 217       NEEDBITS(14)
 218       s->sub.trees.table = t = (uInt)b & 0x3fff;
 219 #ifndef PKZIP_BUG_WORKAROUND
 220       if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
 221       {
 222         s->mode = BAD;
 223         z->msg = (char*)"too many length or distance symbols";
 224         r = Z_DATA_ERROR;
 225         LEAVE
 226       }
 227 #endif
 228       t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
 229       if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
 230       {
 231         r = Z_MEM_ERROR;
 232         LEAVE
 233       }
 234       DUMPBITS(14)
 235       s->sub.trees.index = 0;
 236       Tracev((stderr, "inflate:       table sizes ok\n"));
 237       s->mode = BTREE;
 238     case BTREE:
 239       while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
 240       {
 241         NEEDBITS(3)
 242         s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
 243         DUMPBITS(3)
 244       }
 245       while (s->sub.trees.index < 19)
 246         s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
 247       s->sub.trees.bb = 7;
 248       t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
 249                              &s->sub.trees.tb, s->hufts, z);
 250       if (t != Z_OK)
 251       {
 252         ZFREE(z, s->sub.trees.blens);
 253         r = t;
 254         if (r == Z_DATA_ERROR)
 255           s->mode = BAD;
 256         LEAVE
 257       }
 258       s->sub.trees.index = 0;
 259       Tracev((stderr, "inflate:       bits tree ok\n"));
 260       s->mode = DTREE;
 261     case DTREE:
 262       while (t = s->sub.trees.table,
 263              s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
 264       {
 265         inflate_huft *h;
 266         uInt i, j, c;
 267
 268         t = s->sub.trees.bb;
 269         NEEDBITS(t)
 270         h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
 271         t = h->bits;
 272         c = h->base;
 273         if (c < 16)
 274         {
 275           DUMPBITS(t)
 276           s->sub.trees.blens[s->sub.trees.index++] = c;
 277         }
 278         else /* c == 16..18 */
 279         {
 280           i = c == 18 ? 7 : c - 14;
 281           j = c == 18 ? 11 : 3;
 282           NEEDBITS(t + i)
 283           DUMPBITS(t)
 284           j += (uInt)b & inflate_mask[i];
 285           DUMPBITS(i)
 286           i = s->sub.trees.index;
 287           t = s->sub.trees.table;
 288           if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
 289               (c == 16 && i < 1))
 290           {
 291             ZFREE(z, s->sub.trees.blens);
 292             s->mode = BAD;
 293             z->msg = (char*)"invalid bit length repeat";
 294             r = Z_DATA_ERROR;
 295             LEAVE
 296           }
 297           c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
 298           do {
 299             s->sub.trees.blens[i++] = c;
 300           } while (--j);
 301           s->sub.trees.index = i;
 302         }
 303       }
 304       s->sub.trees.tb = Z_NULL;
 305       {
 306         uInt bl, bd;
 307         inflate_huft *tl, *td;
 308         inflate_codes_statef *c;
 309
 310         bl = 9;         /* must be <= 9 for lookahead assumptions */
 311         bd = 6;         /* must be <= 9 for lookahead assumptions */
 312         t = s->sub.trees.table;
 313         t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
 314                                   s->sub.trees.blens, &bl, &bd, &tl, &td,
 315                                   s->hufts, z);
 316         ZFREE(z, s->sub.trees.blens);
 317         if (t != Z_OK)
 318         {
 319           if (t == (uInt)Z_DATA_ERROR)
 320             s->mode = BAD;
 321           r = t;
 322           LEAVE
 323         }
 324         Tracev((stderr, "inflate:       trees ok\n"));
 325         if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
 326         {
 327           r = Z_MEM_ERROR;
 328           LEAVE
 329         }
 330         s->sub.decode.codes = c;
 331       }
 332       s->mode = CODES;
 333     case CODES:
 334       UPDATE
 335       if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
 336         return inflate_flush(s, z, r);
 337       r = Z_OK;
 338       inflate_codes_free(s->sub.decode.codes, z);
 339       LOAD
 340       Tracev((stderr, "inflate:       codes end, %lu total out\n",
 341               z->total_out + (q >= s->read ? q - s->read :
 342               (s->end - s->read) + (q - s->window))));
 343       if (!s->last)
 344       {
 345         s->mode = TYPE;
 346         break;
 347       }
 348       if (k > 7)              /* return unused byte, if any */
 349       {
 350         Assert(k < 16, "inflate_codes grabbed too many bytes")
 351         k -= 8;
 352         n++;
 353         p--;                    /* can always return one */
 354       }
 355       s->mode = DRY;
 356     case DRY:
 357       FLUSH
 358       if (s->read != s->write)
 359         LEAVE
 360       s->mode = DONE;
 361     case DONE:
 362       r = Z_STREAM_END;
 363       LEAVE
 364     case BAD:
 365       r = Z_DATA_ERROR;
 366       LEAVE
 367     default:
 368       r = Z_STREAM_ERROR;
 369       LEAVE
 370   }
 371 }
 372
 373
 374 int inflate_blocks_free(s, z)
 375 inflate_blocks_statef *s;
 376 z_streamp z;
 377 {
 378   inflate_blocks_reset(s, z, Z_NULL);
 379   ZFREE(z, s->window);
 380   ZFREE(z, s->hufts);
 381   ZFREE(z, s);
 382   Tracev((stderr, "inflate:   blocks freed\n"));
 383   return Z_OK;
 384 }
 385
 386
 387 void inflate_set_dictionary(s, d, n)
 388 inflate_blocks_statef *s;
 389 const Bytef *d;
 390 uInt  n;
 391 {
 392   zmemcpy(s->window, d, n);
 393   s->read = s->write = s->window + n;
 394 }
 395
 396
 397 /* Returns true if inflate is currently at the end of a block generated
 398  * by Z_SYNC_FLUSH or Z_FULL_FLUSH.
 399  * IN assertion: s != Z_NULL
 400  */
 401 int inflate_blocks_sync_point(s)
 402 inflate_blocks_statef *s;
 403 {
 404   return s->mode == LENS;
 405 }