#include <sys/types.h>#include "tailor.h"#if defined(STDC_HEADERS) || !defined(NO_STDLIB_H)#  include <stdlib.h>#endif#include "gzip.h"#define slide windowstruct huft {  uch e;                /* number of extra bits or operation */  uch b;                /* number of bits in this code or subcode */  union {    ush n;              /* literal, length base, or distance base */    struct huft *t;     /* pointer to next level of table */  } v;};/* Function prototypes */int huft_build OF((unsigned *, unsigned, unsigned, ush *, ush *,                   struct huft **, int *));int huft_free OF((struct huft *));int inflate_codes OF((struct huft *, struct huft *, int, int));int inflate_stored OF((void));int inflate_fixed OF((void));int inflate_dynamic OF((void));int inflate_block OF((int *));int inflate OF((void));#define wp outcnt#define flush_output(w) (wp=(w),flush_window())/* Tables for deflate from PKZIP's appnote.txt. */static unsigned border[] = {    /* Order of the bit length code lengths */        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};static ush cplens[] = {         /* Copy lengths for literal codes 257..285 */        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};        /* note: see note #13 above about the 258 in this list. */static ush cplext[] = {         /* Extra bits for literal codes 257..285 */        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99}; /* 99==invalid */static ush cpdist[] = {         /* Copy offsets for distance codes 0..29 */        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,        8193, 12289, 16385, 24577};static ush cpdext[] = {         /* Extra bits for distance codes */        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,        12, 12, 13, 13};ulg bb;                         /* bit buffer */unsigned bk;                    /* bits in bit buffer */ush mask_bits[] = {    0x0000,    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff};#ifdef CRYPT  uch cc;#  define NEXTBYTE() \     (decrypt ? (cc = get_byte(), zdecode(cc), cc) : get_byte())#else#  define NEXTBYTE()  (uch)get_byte()#endif#define NEEDBITS(n) {while(k<(n)){b|=((ulg)NEXTBYTE())<<k;k+=8;}}#define DUMPBITS(n) {b>>=(n);k-=(n);}int lbits = 9;          /* bits in base literal/length lookup table */int dbits = 6;          /* bits in base distance lookup table *//* If BMAX needs to be larger than 16, then h and x[] should be ulg. */#define BMAX 16         /* maximum bit length of any code (16 for explode) */#define N_MAX 288       /* maximum number of codes in any set */unsigned hufts;         /* track memory usage *///int huft_build(unsigned *b, unsigned n, unsigned s, ush *d, ush *e, struct huft **t, int *m)


int huft_build(b, n, s, d, e, t, m)unsigned *b;            /* code lengths in bits (all assumed <= BMAX) */unsigned n;             /* number of codes (assumed <= N_MAX) */unsigned s;             /* number of simple-valued codes (0..s-1) */ush *d;                 /* list of base values for non-simple codes */ush *e;                 /* list of extra bits for non-simple codes */struct huft **t;        /* result: starting table */int *m;                 /* maximum lookup bits, returns actual */{  unsigned a;                   /* counter for codes of length k */  unsigned c[BMAX+1];           /* bit length count table */  unsigned f;                   /* i repeats in table every f entries */  int g;                        /* maximum code length */  int h;                        /* table level */  register unsigned i;          /* counter, current code */  register unsigned j;          /* counter */  register int k;               /* number of bits in current code */  int l;                        /* bits per table (returned in m) */  register unsigned *p;         /* pointer into c[], b[], or v[] */  register struct huft *q;      /* points to current table */  struct huft r;                /* table entry for structure assignment */  struct huft *u[BMAX];         /* table stack */  unsigned v[N_MAX];            /* values in order of bit length */  register int w;               /* bits before this table == (l * h) */  unsigned x[BMAX+1];           /* bit offsets, then code stack */  unsigned *xp;                 /* pointer into x */  int y;                        /* number of dummy codes added */  unsigned z;                   /* number of entries in current table */  /* Generate counts for each bit length */  memzero(c, sizeof(c));  p = b;  i = n;  do {    Tracecv(*p, (stderr, (n-i >= ' ' && n-i <= '~' ? "%c %d\n" : "0x%x %d\n"), 	    n-i, *p));    c[*p]++;                    /* assume all entries <= BMAX */    p++;                      /* Can't combine with above line (Solaris bug) */  } while (--i);  if (c[0] == n)                /* null input--all zero length codes */  {    *t = (struct huft *)NULL;    *m = 0;    return 0;  }  /* Find minimum and maximum length, bound *m by those */  l = *m;  for (j = 1; j <= BMAX; j++)    if (c[j])      break;  k = j;                        /* minimum code length */  if ((unsigned)l < j)    l = j;  for (i = BMAX; i; i--)    if (c[i])      break;  g = i;                        /* maximum code length */  if ((unsigned)l > i)    l = i;  *m = l;  /* Adjust last length count to fill out codes, if needed */  for (y = 1 << j; j < i; j++, y <<= 1)    if ((y -= c[j]) < 0)      return 2;                 /* bad input: more codes than bits */  if ((y -= c[i]) < 0)    return 2;  c[i] += y;  /* Generate starting offsets into the value table for each length */  x[1] = j = 0;  p = c + 1;  xp = x + 2;  while (--i) {                 /* note that i == g from above */    *xp++ = (j += *p++);  }  /* Make a table of values in order of bit lengths */  p = b;  i = 0;  do {    if ((j = *p++) != 0)      v[x[j]++] = i;  } while (++i < n);  /* Generate the Huffman codes and for each, make the table entries */  x[0] = i = 0;                 /* first Huffman code is zero */  p = v;                        /* grab values in bit order */  h = -1;                       /* no tables yet--level -1 */  w = -l;                       /* bits decoded == (l * h) */  u[0] = (struct huft *)NULL;   /* just to keep compilers happy */  q = (struct huft *)NULL;      /* ditto */  z = 0;                        /* ditto */  /* go through the bit lengths (k already is bits in shortest code) */  for (; k <= g; k++)  {    a = c[k];    while (a--)    {      /* here i is the Huffman code of length k bits for value *p */      /* make tables up to required level */      while (k > w + l)      {        h++;        w += l;                 /* previous table always l bits */        /* compute minimum size table less than or equal to l bits */        z = (z = g - w) > (unsigned)l ? l : z;  /* upper limit on table size */        if ((f = 1 << (j = k - w)) > a + 1)     /* try a k-w bit table */        {                       /* too few codes for k-w bit table */          f -= a + 1;           /* deduct codes from patterns left */          xp = c + k;          while (++j < z)       /* try smaller tables up to z bits */          {            if ((f <<= 1) <= *++xp)              break;            /* enough codes to use up j bits */            f -= *xp;           /* else deduct codes from patterns */          }        }        z = 1 << j;             /* table entries for j-bit table */        /* allocate and link in new table */        if ((q = (struct huft *)malloc((z + 1)*sizeof(struct huft))) ==            (struct huft *)NULL)        {          if (h)            huft_free(u[0]);          return 3;             /* not enough memory */        }        hufts += z + 1;         /* track memory usage */        *t = q + 1;             /* link to list for huft_free() */        *(t = &(q->v.t)) = (struct huft *)NULL;        u[h] = ++q;             /* table starts after link */        /* connect to last table, if there is one */        if (h)        {          x[h] = i;             /* save pattern for backing up */          r.b = (uch)l;         /* bits to dump before this table */          r.e = (uch)(16 + j);  /* bits in this table */          r.v.t = q;            /* pointer to this table */          j = i >> (w - l);     /* (get around Turbo C bug) */          u[h-1][j] = r;        /* connect to last table */        }      }      /* set up table entry in r */      r.b = (uch)(k - w);      if (p >= v + n)        r.e = 99;               /* out of values--invalid code */      else if (*p < s)      {        r.e = (uch)(*p < 256 ? 16 : 15);    /* 256 is end-of-block code */        r.v.n = (ush)(*p);             /* simple code is just the value */	p++;                           /* one compiler does not like *p++ */      }      else      {        r.e = (uch)e[*p - s];   /* non-simple--look up in lists */        r.v.n = d[*p++ - s];      }      /* fill code-like entries with r */      f = 1 << (k - w);      for (j = i >> w; j < z; j += f)        q[j] = r;      /* backwards increment the k-bit code i */      for (j = 1 << (k - 1); i & j; j >>= 1)        i ^= j;      i ^= j;      /* backup over finished tables */      while ((i & ((1 << w) - 1)) != x[h])      {        h--;                    /* don't need to update q */        w -= l;      }    }  }  /* Return true (1) if we were given an incomplete table */  return y != 0 && g != 1;}int huft_free(t)struct huft *t;         /* table to free *//* Free the malloc'ed tables built by huft_build(), which makes a linked   list of the tables it made, with the links in a dummy first entry of   each table. */{  register struct huft *p, *q;  /* Go through linked list, freeing from the malloced (t[-1]) address. */  p = t;  while (p != (struct huft *)NULL)  {    q = (--p)->v.t;    free((char*)p);    p = q;  }   return 0;}//int inflate_codes(struct huft *tl, struct huft *td, int bl, int bd)int inflate_codes(tl, td, bl, bd)struct huft *tl, *td;   /* literal/length and distance decoder tables */int bl, bd;             /* number of bits decoded by tl[] and td[] *//* inflate (decompress) the codes in a deflated (compressed) block.   Return an error code or zero if it all goes ok. */{  register unsigned e;  /* table entry flag/number of extra bits */  unsigned n, d;        /* length and index for copy */  unsigned long  w;           /* current window position */  struct huft *t;       /* pointer to table entry */  unsigned ml, md;      /* masks for bl and bd bits */  register ulg b;       /* bit buffer */  register unsigned k;  /* number of bits in bit buffer */  long nk = 0;  /* make local copies of globals */  b = bb;                       /* initialize bit buffer */  k = bk;  w = wp;                       /* initialize window position */  /* inflate the coded data */  ml = mask_bits[bl];           /* precompute masks for speed */  md = mask_bits[bd];  for (;;)                      /* do until end of block */  {    NEEDBITS((unsigned)bl)    if ((e = (t = tl + ((unsigned)b & ml))->e) > 16)      do {        if (e == 99)          return 1;        DUMPBITS(t->b)        e -= 16;        NEEDBITS(e)      } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);    DUMPBITS(t->b)    if (e == 16)                /* then it's a literal */    {      slide[w++] = (uch)t->v.n;      Tracevv((stderr, "%c", slide[w-1]));      if (w == WSIZE)      {        flush_output(w);        w = 0;      }    }    else                        /* it's an EOB or a length */    {      /* exit if end of block */      if (e == 15)        break;      /* get length of block to copy */      NEEDBITS(e)      n = t->v.n + ((unsigned)b & mask_bits[e]);      DUMPBITS(e);      /* decode distance of block to copy */      NEEDBITS((unsigned)bd)      if ((e = (t = td + ((unsigned)b & md))->e) > 16)        do {          if (e == 99)            return 1;          DUMPBITS(t->b)          e -= 16;          NEEDBITS(e)        } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);      DUMPBITS(t->b)      NEEDBITS(e)      d = w - t->v.n - ((unsigned)b & mask_bits[e]);      DUMPBITS(e)      Tracevv((stderr,"\\[%d,%d]", w-d, n));      /* do the copy */      do {        n -= (e = (e = WSIZE - ((d &= WSIZE-1) > w ? d : w)) > n ? n : e);#if !defined(NOMEMCPY) && !defined(DEBUG)        if (w - d >= e)         /* (this test assumes unsigned comparison) */        {