/* inflate.c -- zlib interface to inflate modules

  * Copyright (C) 1995-1998 Mark Adler

  * For conditions of distribution and use, see copyright notice in zlib.h 

  */

 #include "zutil.h"

 #include "infblock.h"

 struct inflate_blocks_state {int dummy;}; /* for buggy compilers */

 typedef enum {

       METHOD,   /* waiting for method byte */

       FLAG,     /* waiting for flag byte */

       DICT4,    /* four dictionary check bytes to go */

       DICT3,    /* three dictionary check bytes to go */

       DICT2,    /* two dictionary check bytes to go */

       DICT1,    /* one dictionary check byte to go */

       DICT0,    /* waiting for inflateSetDictionary */

       BLOCKS,   /* decompressing blocks */

       CHECK4,   /* four check bytes to go */

       CHECK3,   /* three check bytes to go */

       CHECK2,   /* two check bytes to go */

       CHECK1,   /* one check byte to go */

       DONE,     /* finished check, done */

       BAD}      /* got an error--stay here */

 inflate_mode;

 /* inflate private state */

 struct internal_state {

   /* mode */

   inflate_mode  mode;   /* current inflate mode */

   /* mode dependent information */

   union {

     uInt method;        /* if FLAGS, method byte */

     struct {

       uLong was;                /* computed check value */

       uLong need;               /* stream check value */

     } check;            /* if CHECK, check values to compare */

     uInt marker;        /* if BAD, inflateSync's marker bytes count */

   } sub;        /* submode */

   /* mode independent information */

   int  nowrap;          /* flag for no wrapper */

   uInt wbits;           /* log2(window size)  (8..15, defaults to 15) */

   inflate_blocks_statef 

     *blocks;            /* current inflate_blocks state */

 };

 int ZEXPORT inflateReset(z_streamp z)

 {

   if (z == Z_NULL || z->state == Z_NULL)

     return Z_STREAM_ERROR;

   z->total_in = z->total_out = 0;

   z->msg = Z_NULL;

   z->state->mode = z->state->nowrap ? BLOCKS : METHOD;

   inflate_blocks_reset(z->state->blocks, z, Z_NULL);

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

   return Z_OK;

 }

 int ZEXPORT inflateEnd(z_streamp z)

 {

   if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)

     return Z_STREAM_ERROR;

   if (z->state->blocks != Z_NULL)

     inflate_blocks_free(z->state->blocks, z);

   ZFREE(z, z->state);

   z->state = Z_NULL;

   Tracev((stderr, "inflate: end\n"));

   return Z_OK;

 }

 int ZEXPORT inflateInit2_(z_streamp z, int w, const char *version, int stream_size)

 {

   if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||

       stream_size != sizeof(z_stream))

       return Z_VERSION_ERROR;

   /* initialize state */

   if (z == Z_NULL)

     return Z_STREAM_ERROR;

   z->msg = Z_NULL;

   if (z->zalloc == Z_NULL)

   {

     z->zalloc = zcalloc;

     z->opaque = (voidpf)0;

   }

   if (z->zfree == Z_NULL) z->zfree = zcfree;

   if ((z->state = (struct internal_state FAR *)

        ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL)

     return Z_MEM_ERROR;

   z->state->blocks = Z_NULL;

   /* handle undocumented nowrap option (no zlib header or check) */

   z->state->nowrap = 0;

   if (w < 0)

   {

     w = - w;

     z->state->nowrap = 1;

   }

   /* set window size */

   if (w < 8 || w > 15)

   {

     inflateEnd(z);

     return Z_STREAM_ERROR;

   }

   z->state->wbits = (uInt)w;

   /* create inflate_blocks state */

   if ((z->state->blocks =

       inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w))

       == Z_NULL)

   {

     inflateEnd(z);

     return Z_MEM_ERROR;

   }

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

   /* reset state */

   inflateReset(z);

   return Z_OK;

 }

 int ZEXPORT inflateInit_(z_streamp z, const char *version, int stream_size)

 {

   return inflateInit2_(z, DEF_WBITS, version, stream_size);

 }

 #define NEEDBYTE {if(z->avail_in==0)return r;r=f;}

 #define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++)

 int ZEXPORT inflate(z_streamp z, int f)

 {

   int r;

   uInt b;

   if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL)

     return Z_STREAM_ERROR;

   f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;

   r = Z_BUF_ERROR;

   while (1) switch (z->state->mode)

   {

     case METHOD:

       NEEDBYTE

       if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED)

       {

         z->state->mode = BAD;

         z->msg = (char*)"unknown compression method";

         z->state->sub.marker = 5;       /* can't try inflateSync */

         break;

       }

       if ((z->state->sub.method >> 4) + 8 > z->state->wbits)

       {

         z->state->mode = BAD;

         z->msg = (char*)"invalid window size";

         z->state->sub.marker = 5;       /* can't try inflateSync */

         break;

       }

       z->state->mode = FLAG;

     case FLAG:

       NEEDBYTE

       b = NEXTBYTE;

       if (((z->state->sub.method << 8) + b) % 31)

       {

         z->state->mode = BAD;

         z->msg = (char*)"incorrect header check";

         z->state->sub.marker = 5;       /* can't try inflateSync */

         break;

       }

       Tracev((stderr, "inflate: zlib header ok\n"));

       if (!(b & PRESET_DICT))

       {

         z->state->mode = BLOCKS;

         break;

       }

       z->state->mode = DICT4;

     case DICT4:

       NEEDBYTE

       z->state->sub.check.need = (uLong)NEXTBYTE << 24;

       z->state->mode = DICT3;

     case DICT3:

       NEEDBYTE

       z->state->sub.check.need += (uLong)NEXTBYTE << 16;

       z->state->mode = DICT2;

     case DICT2:

       NEEDBYTE

       z->state->sub.check.need += (uLong)NEXTBYTE << 8;

       z->state->mode = DICT1;

     case DICT1:

       NEEDBYTE

       z->state->sub.check.need += (uLong)NEXTBYTE;

       z->adler = z->state->sub.check.need;

       z->state->mode = DICT0;

       return Z_NEED_DICT;

     case DICT0:

       z->state->mode = BAD;

       z->msg = (char*)"need dictionary";

       z->state->sub.marker = 0;       /* can try inflateSync */

       return Z_STREAM_ERROR;

     case BLOCKS:

       r = inflate_blocks(z->state->blocks, z, r);

       if (r == Z_DATA_ERROR)

       {

         z->state->mode = BAD;

         z->state->sub.marker = 0;       /* can try inflateSync */

         break;

       }

       if (r == Z_OK)

         r = f;

       if (r != Z_STREAM_END)

         return r;

       r = f;

       inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was);

       if (z->state->nowrap)

       {

         z->state->mode = DONE;

         break;

       }

       z->state->mode = CHECK4;

     case CHECK4:

       NEEDBYTE

       z->state->sub.check.need = (uLong)NEXTBYTE << 24;

       z->state->mode = CHECK3;

     case CHECK3:

       NEEDBYTE

       z->state->sub.check.need += (uLong)NEXTBYTE << 16;

       z->state->mode = CHECK2;

     case CHECK2:

       NEEDBYTE

       z->state->sub.check.need += (uLong)NEXTBYTE << 8;

       z->state->mode = CHECK1;

     case CHECK1:

       NEEDBYTE

       z->state->sub.check.need += (uLong)NEXTBYTE;

       if (z->state->sub.check.was != z->state->sub.check.need)

       {

         z->state->mode = BAD;

         z->msg = (char*)"incorrect data check";

         z->state->sub.marker = 5;       /* can't try inflateSync */

         break;

       }

       Tracev((stderr, "inflate: zlib check ok\n"));

       z->state->mode = DONE;

     case DONE:

       return Z_STREAM_END;

     case BAD:

       return Z_DATA_ERROR;

     default:

       return Z_STREAM_ERROR;

   }

 #ifdef NEED_DUMMY_RETURN

   return Z_STREAM_ERROR;  /* Some dumb compilers complain without this */

 #endif

 }

 int ZEXPORT inflateSetDictionary(z_streamp z,const Bytef *dictionary, uInt dictLength)

 {

   uInt length = dictLength;

   if (z == Z_NULL || z->state == Z_NULL || z->state->mode != DICT0)

     return Z_STREAM_ERROR;

   if (adler32(1L, dictionary, dictLength) != z->adler) return Z_DATA_ERROR;

   z->adler = 1L;

   if (length >= ((uInt)1<<z->state->wbits))

   {

     length = (1<<z->state->wbits)-1;

     dictionary += dictLength - length;

   }

   inflate_set_dictionary(z->state->blocks, dictionary, length);

   z->state->mode = BLOCKS;

   return Z_OK;

 }

 int ZEXPORT inflateSync(z_streamp z)

 {

   uInt n;       /* number of bytes to look at */

   Bytef *p;     /* pointer to bytes */

   uInt m;       /* number of marker bytes found in a row */

   uLong r, w;   /* temporaries to save total_in and total_out */

   /* set up */

   if (z == Z_NULL || z->state == Z_NULL)

     return Z_STREAM_ERROR;

   if (z->state->mode != BAD)

   {

     z->state->mode = BAD;

     z->state->sub.marker = 0;

   }

   if ((n = z->avail_in) == 0)

     return Z_BUF_ERROR;

   p = z->next_in;

   m = z->state->sub.marker;

   /* search */

   while (n && m < 4)

   {

     static const Byte mark[4] = {0, 0, 0xff, 0xff};

     if (*p == mark[m])

       m++;

     else if (*p)

       m = 0;

     else

       m = 4 - m;

     p++, n--;

   }

   /* restore */

   z->total_in += p - z->next_in;

   z->next_in = p;

   z->avail_in = n;

   z->state->sub.marker = m;

   /* return no joy or set up to restart on a new block */

   if (m != 4)

     return Z_DATA_ERROR;

   r = z->total_in;  w = z->total_out;

   inflateReset(z);

   z->total_in = r;  z->total_out = w;

   z->state->mode = BLOCKS;

   return Z_OK;

 }

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

  * by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP

  * implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH

  * but removes the length bytes of the resulting empty stored block. When

  * decompressing, PPP checks that at the end of input packet, inflate is

  * waiting for these length bytes.

  */

 int ZEXPORT inflateSyncPoint(z_streamp z)

 {

   if (z == Z_NULL || z->state == Z_NULL || z->state->blocks == Z_NULL)

     return Z_STREAM_ERROR;

   return inflate_blocks_sync_point(z->state->blocks);

 }