thirdparty/freetype-2.3.12/src/gzip/inflate.c

   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