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

     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 

     9 #define  DONE  INFLATE_DONE

    10 #define  BAD   INFLATE_BAD

    11 

    12 typedef enum {

    13       METHOD,   /* waiting for method byte */

    14       FLAG,     /* waiting for flag byte */

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

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

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

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

    19       DICT0,    /* waiting for inflateSetDictionary */

    20       BLOCKS,   /* decompressing blocks */

    21       CHECK4,   /* four check bytes to go */

    22       CHECK3,   /* three check bytes to go */

    23       CHECK2,   /* two check bytes to go */

    24       CHECK1,   /* one check byte to go */

    25       DONE,     /* finished check, done */

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

    27 inflate_mode;

    28 

    29 /* inflate private state */

    30 struct internal_state {

    31 

    32   /* mode */

    33   inflate_mode  mode;   /* current inflate mode */

    34 

    35   /* mode dependent information */

    36   union {

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

    38     struct {

    39       uLong was;                /* computed check value */

    40       uLong need;               /* stream check value */

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

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

    43   } sub;        /* submode */

    44 

    45   /* mode independent information */

    46   int  nowrap;          /* flag for no wrapper */

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

    48   inflate_blocks_statef

    49     *blocks;            /* current inflate_blocks state */

    50 

    51 };

    52 

    53 

    54 ZEXPORT(int) inflateReset( /* z) */

    55 z_streamp z )

    56 {

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

    58     return Z_STREAM_ERROR;

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

    60   z->msg = Z_NULL;

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

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

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

    64   return Z_OK;

    65 }

    66 

    67 

    68 ZEXPORT(int) inflateEnd( /* z) */

    69 z_streamp z )

    70 {

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

    72     return Z_STREAM_ERROR;

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

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

    75   ZFREE(z, z->state);

    76   z->state = Z_NULL;

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

    78   return Z_OK;

    79 }

    80 

    81 

    82 ZEXPORT(int) inflateInit2_( /* z, w, version, stream_size) */

    83 z_streamp z,

    84 int w,

    85 const char *version,

    86 int stream_size )

    87 {

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

    89       stream_size != sizeof(z_stream))

    90       return Z_VERSION_ERROR;

    91 

    92   /* initialize state */

    93   if (z == Z_NULL)

    94     return Z_STREAM_ERROR;

    95   z->msg = Z_NULL;

    96   if (z->zalloc == Z_NULL)

    97   {

    98     z->zalloc = zcalloc;

    99     z->opaque = (voidpf)0;

   100   }

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

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

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

   104     return Z_MEM_ERROR;

   105   z->state->blocks = Z_NULL;

   106 

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

   108   z->state->nowrap = 0;

   109   if (w < 0)

   110   {

   111     w = - w;

   112     z->state->nowrap = 1;

   113   }

   114 

   115   /* set window size */

   116   if (w < 8 || w > 15)

   117   {

   118     inflateEnd(z);

   119     return Z_STREAM_ERROR;

   120   }

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

   122 

   123   /* create inflate_blocks state */

   124   if ((z->state->blocks =

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

   126       == Z_NULL)

   127   {

   128     inflateEnd(z);

   129     return Z_MEM_ERROR;

   130   }

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

   132 

   133   /* reset state */

   134   inflateReset(z);

   135   return Z_OK;

   136 }

   137 

   138 

   139 

   140 #undef  NEEDBYTE

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

   142 

   143 #undef  NEXTBYTE

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

   145 

   146 

   147 ZEXPORT(int) inflate( /* z, f) */

   148 z_streamp z,

   149 int f )

   150 {

   151   int r;

   152   uInt b;

   153 

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

   155     return Z_STREAM_ERROR;

   156   f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;

   157   r = Z_BUF_ERROR;

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

   159   {

   160     case METHOD:

   161       NEEDBYTE

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

   163       {

   164         z->state->mode = BAD;

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

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

   167         break;

   168       }

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

   170       {

   171         z->state->mode = BAD;

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

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

   174         break;

   175       }

   176       z->state->mode = FLAG;

   177     case FLAG:

   178       NEEDBYTE

   179       b = NEXTBYTE;

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

   181       {

   182         z->state->mode = BAD;

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

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

   185         break;

   186       }

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

   188       if (!(b & PRESET_DICT))

   189       {

   190         z->state->mode = BLOCKS;

   191         break;

   192       }

   193       z->state->mode = DICT4;

   194     case DICT4:

   195       NEEDBYTE

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

   197       z->state->mode = DICT3;

   198     case DICT3:

   199       NEEDBYTE

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

   201       z->state->mode = DICT2;

   202     case DICT2:

   203       NEEDBYTE

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

   205       z->state->mode = DICT1;

   206     case DICT1:

   207       NEEDBYTE

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

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

   210       z->state->mode = DICT0;

   211       return Z_NEED_DICT;

   212     case DICT0:

   213       z->state->mode = BAD;

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

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

   216       return Z_STREAM_ERROR;

   217     case BLOCKS:

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

   219       if (r == Z_DATA_ERROR)

   220       {

   221         z->state->mode = BAD;

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

   223         break;

   224       }

   225       if (r == Z_OK)

   226         r = f;

   227       if (r != Z_STREAM_END)

   228         return r;

   229       r = f;

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

   231       if (z->state->nowrap)

   232       {

   233         z->state->mode = DONE;

   234         break;

   235       }

   236       z->state->mode = CHECK4;

   237     case CHECK4:

   238       NEEDBYTE

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

   240       z->state->mode = CHECK3;

   241     case CHECK3:

   242       NEEDBYTE

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

   244       z->state->mode = CHECK2;

   245     case CHECK2:

   246       NEEDBYTE

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

   248       z->state->mode = CHECK1;

   249     case CHECK1:

   250       NEEDBYTE

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

   252 

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

   254       {

   255         z->state->mode = BAD;

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

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

   258         break;

   259       }

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

   261       z->state->mode = DONE;

   262     case DONE:

   263       return Z_STREAM_END;

   264     case BAD:

   265       return Z_DATA_ERROR;

   266     default:

   267       return Z_STREAM_ERROR;

   268   }

   269 #ifdef NEED_DUMMY_RETURN

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

   271 #endif

   272 }

   273