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(inflate_blocks_statef *s, z_streamp z, uLongf *c)

    69 {

    70   if (c != Z_NULL)

    71     *c = s->check;

    72   if (s->mode == BTREE || s->mode == DTREE)

    73     ZFREE(z, s->sub.trees.blens);

    74   if (s->mode == CODES)

    75     inflate_codes_free(s->sub.decode.codes, z);

    76   s->mode = TYPE;

    77   s->bitk = 0;

    78   s->bitb = 0;

    79   s->read = s->write = s->window;

    80   if (s->checkfn != Z_NULL)

    81     z->adler = s->check = (*s->checkfn)(0L, (const Bytef *)Z_NULL, 0);

    82   Tracev((stderr, "inflate:   blocks reset\n"));

    83 }

    84 

    85 

    86 inflate_blocks_statef *inflate_blocks_new(z_streamp z, check_func c, uInt w)

    87 {

    88   inflate_blocks_statef *s;

    89 

    90   if ((s = (inflate_blocks_statef *)ZALLOC

    91        (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)

    92     return s;

    93   if ((s->hufts =

    94        (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL)

    95   {

    96     ZFREE(z, s);

    97     return Z_NULL;

    98   }

    99   if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)

   100   {

   101     ZFREE(z, s->hufts);

   102     ZFREE(z, s);

   103     return Z_NULL;

   104   }

   105   s->end = s->window + w;

   106   s->checkfn = c;

   107   s->mode = TYPE;

   108   Tracev((stderr, "inflate:   blocks allocated\n"));

   109   inflate_blocks_reset(s, z, Z_NULL);

   110   return s;

   111 }

   112 

   113 

   114 int inflate_blocks(inflate_blocks_statef *s, z_streamp z, int r)

   115 {

   116   uInt t;               /* temporary storage */

   117   uLong b;              /* bit buffer */

   118   uInt k;               /* bits in bit buffer */

   119   Bytef *p;             /* input data pointer */

   120   uInt n;               /* bytes available there */

   121   Bytef *q;             /* output window write pointer */

   122   uInt m;               /* bytes to end of window or read pointer */

   123 

   124   /* copy input/output information to locals (UPDATE macro restores) */

   125   LOAD

   126 

   127   /* process input based on current state */

   128   while (1) switch (s->mode)

   129   {

   130     case TYPE:

   131       NEEDBITS(3)

   132       t = (uInt)b & 7;

   133       s->last = t & 1;

   134       switch (t >> 1)

   135       {

   136         case 0:                         /* stored */

   137           Tracev((stderr, "inflate:     stored block%s\n",

   138                  s->last ? " (last)" : ""));

   139           DUMPBITS(3)

   140           t = k & 7;                    /* go to byte boundary */

   141           DUMPBITS(t)

   142           s->mode = LENS;               /* get length of stored block */

   143           break;

   144         case 1:                         /* fixed */

   145           Tracev((stderr, "inflate:     fixed codes block%s\n",

   146                  s->last ? " (last)" : ""));

   147           {

   148             uInt bl, bd;

   149             inflate_huft *tl, *td;

   150 

   151             inflate_trees_fixed(&bl, &bd, &tl, &td, z);

   152             s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);

   153             if (s->sub.decode.codes == Z_NULL)

   154             {

   155               r = Z_MEM_ERROR;

   156               LEAVE

   157             }

   158           }

   159           DUMPBITS(3)

   160           s->mode = CODES;

   161           break;

   162         case 2:                         /* dynamic */

   163           Tracev((stderr, "inflate:     dynamic codes block%s\n",

   164                  s->last ? " (last)" : ""));

   165           DUMPBITS(3)

   166           s->mode = TABLE;

   167           break;

   168         case 3:                         /* illegal */

   169           DUMPBITS(3)

   170           s->mode = BAD;

   171           z->msg = (char*)"invalid block type";

   172           r = Z_DATA_ERROR;

   173           LEAVE

   174       }

   175       break;

   176     case LENS:

   177       NEEDBITS(32)

   178       if ((((~b) >> 16) & 0xffff) != (b & 0xffff))

   179       {

   180         s->mode = BAD;

   181         z->msg = (char*)"invalid stored block lengths";

   182         r = Z_DATA_ERROR;

   183         LEAVE

   184       }

   185       s->sub.left = (uInt)b & 0xffff;

   186       b = k = 0;                      /* dump bits */

   187       Tracev((stderr, "inflate:       stored length %u\n", s->sub.left));

   188       s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE);

   189       break;

   190     case STORED:

   191       if (n == 0)

   192         LEAVE

   193       NEEDOUT

   194       t = s->sub.left;

   195       if (t > n) t = n;

   196       if (t > m) t = m;

   197       zmemcpy(q, p, t);

   198       p += t;  n -= t;

   199       q += t;  m -= t;

   200       if ((s->sub.left -= t) != 0)

   201         break;

   202       Tracev((stderr, "inflate:       stored end, %lu total out\n",

   203               z->total_out + (q >= s->read ? q - s->read :

   204               (s->end - s->read) + (q - s->window))));

   205       s->mode = s->last ? DRY : TYPE;

   206       break;

   207     case TABLE:

   208       NEEDBITS(14)

   209       s->sub.trees.table = t = (uInt)b & 0x3fff;

   210 #ifndef PKZIP_BUG_WORKAROUND

   211       if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)

   212       {

   213         s->mode = BAD;

   214         z->msg = (char*)"too many length or distance symbols";

   215         r = Z_DATA_ERROR;

   216         LEAVE

   217       }

   218 #endif

   219       t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);

   220       if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)

   221       {

   222         r = Z_MEM_ERROR;

   223         LEAVE

   224       }

   225       DUMPBITS(14)

   226       s->sub.trees.index = 0;

   227       Tracev((stderr, "inflate:       table sizes ok\n"));

   228       s->mode = BTREE;

   229     case BTREE:

   230       while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))

   231       {

   232         NEEDBITS(3)

   233         s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;

   234         DUMPBITS(3)

   235       }

   236       while (s->sub.trees.index < 19)

   237         s->sub.trees.blens[border[s->sub.trees.index++]] = 0;

   238       s->sub.trees.bb = 7;

   239       t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,

   240                              &s->sub.trees.tb, s->hufts, z);

   241       if (t != Z_OK)

   242       {

   243         ZFREE(z, s->sub.trees.blens);

   244         r = t;

   245         if (r == Z_DATA_ERROR)

   246           s->mode = BAD;

   247         LEAVE

   248       }

   249       s->sub.trees.index = 0;

   250       Tracev((stderr, "inflate:       bits tree ok\n"));

   251       s->mode = DTREE;

   252     case DTREE:

   253       while (t = s->sub.trees.table,

   254              s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))

   255       {

   256         inflate_huft *h;

   257         uInt i, j, c;

   258 

   259         t = s->sub.trees.bb;

   260         NEEDBITS(t)

   261         h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);

   262         t = h->bits;

   263         c = h->base;

   264         if (c < 16)

   265         {

   266           DUMPBITS(t)

   267           s->sub.trees.blens[s->sub.trees.index++] = c;

   268         }

   269         else /* c == 16..18 */

   270         {

   271           i = c == 18 ? 7 : c - 14;

   272           j = c == 18 ? 11 : 3;

   273           NEEDBITS(t + i)

   274           DUMPBITS(t)

   275           j += (uInt)b & inflate_mask[i];

   276           DUMPBITS(i)

   277           i = s->sub.trees.index;

   278           t = s->sub.trees.table;

   279           if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||

   280               (c == 16 && i < 1))

   281           {

   282             ZFREE(z, s->sub.trees.blens);

   283             s->mode = BAD;

   284             z->msg = (char*)"invalid bit length repeat";

   285             r = Z_DATA_ERROR;

   286             LEAVE

   287           }

   288           c = c == 16 ? s->sub.trees.blens[i - 1] : 0;

   289           do {

   290             s->sub.trees.blens[i++] = c;

   291           } while (--j);

   292           s->sub.trees.index = i;

   293         }

   294       }

   295       s->sub.trees.tb = Z_NULL;

   296       {

   297         uInt bl, bd;

   298         inflate_huft *tl, *td;

   299         inflate_codes_statef *c;

   300 

   301         bl = 9;         /* must be <= 9 for lookahead assumptions */

   302         bd = 6;         /* must be <= 9 for lookahead assumptions */

   303         t = s->sub.trees.table;

   304         t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),

   305                                   s->sub.trees.blens, &bl, &bd, &tl, &td,

   306                                   s->hufts, z);

   307         ZFREE(z, s->sub.trees.blens);

   308         if (t != Z_OK)

   309         {

   310           if (t == (uInt)Z_DATA_ERROR)

   311             s->mode = BAD;

   312           r = t;

   313           LEAVE

   314         }

   315         Tracev((stderr, "inflate:       trees ok\n"));

   316         if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)

   317         {

   318           r = Z_MEM_ERROR;

   319           LEAVE

   320         }

   321         s->sub.decode.codes = c;

   322       }

   323       s->mode = CODES;

   324     case CODES:

   325       UPDATE

   326       if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)

   327         return inflate_flush(s, z, r);

   328       r = Z_OK;

   329       inflate_codes_free(s->sub.decode.codes, z);

   330       LOAD

   331       Tracev((stderr, "inflate:       codes end, %lu total out\n",

   332               z->total_out + (q >= s->read ? q - s->read :

   333               (s->end - s->read) + (q - s->window))));

   334       if (!s->last)

   335       {

   336         s->mode = TYPE;

   337         break;

   338       }

   339       s->mode = DRY;

   340     case DRY:

   341       FLUSH

   342       if (s->read != s->write)

   343         LEAVE

   344       s->mode = DONE;

   345     case DONE:

   346       r = Z_STREAM_END;

   347       LEAVE

   348     case BAD:

   349       r = Z_DATA_ERROR;

   350       LEAVE

   351     default:

   352       r = Z_STREAM_ERROR;

   353       LEAVE

   354   }

   355 }

   356 

   357 

   358 int inflate_blocks_free(inflate_blocks_statef *s, z_streamp z)

   359 {

   360   inflate_blocks_reset(s, z, Z_NULL);

   361   ZFREE(z, s->window);

   362   ZFREE(z, s->hufts);

   363   ZFREE(z, s);

   364   Tracev((stderr, "inflate:   blocks freed\n"));

   365   return Z_OK;

   366 }

   367 

   368 

   369 void inflate_set_dictionary(inflate_blocks_statef *s, const Bytef *d, uInt n)

   370 {

   371   zmemcpy(s->window, d, n);

   372   s->read = s->write = s->window + n;

   373 }

   374 

   375 

   376 /* Returns true if inflate is currently at the end of a block generated

   377  * by Z_SYNC_FLUSH or Z_FULL_FLUSH. 

   378  * IN assertion: s != Z_NULL

   379  */

   380 int inflate_blocks_sync_point(inflate_blocks_statef *s)

   381 {

   382   return s->mode == LENS;

   383 }