1 /* infback.cpp -- inflate using a call-back interface

     2  * Copyright (C) 1995-2005 Mark Adler

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

     4  */

     5 

     6 /*

     7    This code is largely copied from inflate.c.  Normally either infback.o or

     8    inflate.o would be linked into an application--not both.  The interface

     9    with inffast.c is retained so that optimized assembler-coded versions of

    10    inflate_fast() can be used with either inflate.c or infback.c.

    11  */

    12 

    13 #include "zutil.h"

    14 #include "inftrees.h"

    15 #include "inflate.h"

    16 #include "inffast.h"

    17 

    18 /* function prototypes */

    19 local void fixedtables OF((struct inflate_state FAR *state));

    20 

    21 /*

    22    strm provides memory allocation functions in zalloc and zfree, or

    23    Z_NULL to use the library memory allocation functions.

    24 

    25    windowBits is in the range 8..15, and window is a user-supplied

    26    window and output buffer that is 2**windowBits bytes.

    27  */

    28 

    29 #ifdef __SYMBIAN32__

    30 EXPORT_C int inflateBackInit__r(z_streamp strm, int windowBits,unsigned char FAR *  window,const char *  version,int stream_size)

    31 #else

    32 int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)

    33 z_streamp strm;

    34 int windowBits;

    35 unsigned char FAR *window;

    36 const char *version;

    37 int stream_size;

    38 #endif //__SYMBIAN32__

    39 {

    40     struct inflate_state FAR *state;

    41 

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

    43         stream_size != (int)(sizeof(z_stream)))

    44         return Z_VERSION_ERROR;

    45     if (strm == Z_NULL || window == Z_NULL ||

    46         windowBits < 8 || windowBits > 15)

    47         return Z_STREAM_ERROR;

    48     strm->msg = Z_NULL;                 /* in case we return an error */

    49     if (strm->zalloc == (alloc_func)0) {

    50         strm->zalloc = zcalloc;

    51         strm->opaque = (voidpf)0;

    52     }

    53     if (strm->zfree == (free_func)0) strm->zfree = zcfree;

    54     state = (struct inflate_state FAR *)ZALLOC(strm, 1,

    55                                                sizeof(struct inflate_state));

    56     if (state == Z_NULL) return Z_MEM_ERROR;

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

    58     strm->state = (struct internal_state FAR *)state;

    59     state->dmax = 32768U;

    60     state->wbits = windowBits;

    61     state->wsize = 1U << windowBits;

    62     state->window = window;

    63     state->write = 0;

    64     state->whave = 0;

    65     return Z_OK;

    66 }

    67 

    68 

    69 /*

    70    Return state with length and distance decoding tables and index sizes set to

    71    fixed code decoding.  Normally this returns fixed tables from inffixed.h.

    72    If BUILDFIXED is defined, then instead this routine builds the tables the

    73    first time it's called, and returns those tables the first time and

    74    thereafter.  This reduces the size of the code by about 2K bytes, in

    75    exchange for a little execution time.  However, BUILDFIXED should not be

    76    used for threaded applications, since the rewriting of the tables and virgin

    77    may not be thread-safe.

    78  */

    79 

    80 #ifdef __SYMBIAN32__

    81 local void fixedtables(struct inflate_state FAR * state)

    82 #else

    83 local void fixedtables(state)

    84 struct inflate_state FAR *state;

    85 #endif //__SYMBIAN32__

    86 {

    87 #ifdef BUILDFIXED

    88     static int virgin = 1;

    89     static code *lenfix, *distfix;

    90     static code fixed[544];

    91 

    92     /* build fixed huffman tables if first call (may not be thread safe) */

    93     if (virgin) {

    94         unsigned sym, bits;

    95         static code *next;

    96 

    97         /* literal/length table */

    98         sym = 0;

    99         while (sym < 144) state->lens[sym++] = 8;

   100         while (sym < 256) state->lens[sym++] = 9;

   101         while (sym < 280) state->lens[sym++] = 7;

   102         while (sym < 288) state->lens[sym++] = 8;

   103         next = fixed;

   104         lenfix = next;

   105         bits = 9;

   106         inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);

   107 

   108         /* distance table */

   109         sym = 0;

   110         while (sym < 32) state->lens[sym++] = 5;

   111         distfix = next;

   112         bits = 5;

   113         inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);

   114 

   115         /* do this just once */

   116         virgin = 0;

   117     }

   118 #else /* !BUILDFIXED */

   119 #   include "inffixed.h"

   120 #endif /* BUILDFIXED */

   121     state->lencode = lenfix;

   122     state->lenbits = 9;

   123     state->distcode = distfix;

   124     state->distbits = 5;

   125 }

   126 

   127 

   128 /* Macros for inflateBack(): */

   129 

   130 /* Load returned state from inflate_fast() */

   131 #define LOAD() \

   132     do { \

   133         put = strm->next_out; \

   134         left = strm->avail_out; \

   135         next = strm->next_in; \

   136         have = strm->avail_in; \

   137         hold = state->hold; \

   138         bits = state->bits; \

   139     } while (0)

   140 

   141 /* Set state from registers for inflate_fast() */

   142 #define RESTORE() \

   143     do { \

   144         strm->next_out = put; \

   145         strm->avail_out = left; \

   146         strm->next_in = next; \

   147         strm->avail_in = have; \

   148         state->hold = hold; \

   149         state->bits = bits; \

   150     } while (0)

   151 

   152 /* Clear the input bit accumulator */

   153 #define INITBITS() \

   154     do { \

   155         hold = 0; \

   156         bits = 0; \

   157     } while (0)

   158 

   159 /* Assure that some input is available.  If input is requested, but denied,

   160    then return a Z_BUF_ERROR from inflateBack(). */

   161 #define PULL() \

   162     do { \

   163         if (have == 0) { \

   164             have = in(in_desc, &next); \

   165             if (have == 0) { \

   166                 next = Z_NULL; \

   167                 ret = Z_BUF_ERROR; \

   168                 goto inf_leave; \

   169             } \

   170         } \

   171     } while (0)

   172 

   173 /* Get a byte of input into the bit accumulator, or return from inflateBack()

   174    with an error if there is no input available. */

   175 #define PULLBYTE() \

   176     do { \

   177         PULL(); \

   178         have--; \

   179         hold += (unsigned long)(*next++) << bits; \

   180         bits += 8; \

   181     } while (0)

   182 

   183 /* Assure that there are at least n bits in the bit accumulator.  If there is

   184    not enough available input to do that, then return from inflateBack() with

   185    an error. */

   186 #define NEEDBITS(n) \

   187     do { \

   188         while (bits < (unsigned)(n)) \

   189             PULLBYTE(); \

   190     } while (0)

   191 

   192 /* Return the low n bits of the bit accumulator (n < 16) */

   193 #define BITS(n) \

   194     ((unsigned)hold & ((1U << (n)) - 1))

   195 

   196 /* Remove n bits from the bit accumulator */

   197 #define DROPBITS(n) \

   198     do { \

   199         hold >>= (n); \

   200         bits -= (unsigned)(n); \

   201     } while (0)

   202 

   203 /* Remove zero to seven bits as needed to go to a byte boundary */

   204 #define BYTEBITS() \

   205     do { \

   206         hold >>= bits & 7; \

   207         bits -= bits & 7; \

   208     } while (0)

   209 

   210 /* Assure that some output space is available, by writing out the window

   211    if it's full.  If the write fails, return from inflateBack() with a

   212    Z_BUF_ERROR. */

   213 #define ROOM() \

   214     do { \

   215         if (left == 0) { \

   216             put = state->window; \

   217             left = state->wsize; \

   218             state->whave = left; \

   219             if (out(out_desc, put, left)) { \

   220                 ret = Z_BUF_ERROR; \

   221                 goto inf_leave; \

   222             } \

   223         } \

   224     } while (0)

   225 

   226 /*

   227    strm provides the memory allocation functions and window buffer on input,

   228    and provides information on the unused input on return.  For Z_DATA_ERROR

   229    returns, strm will also provide an error message.

   230 

   231    in() and out() are the call-back input and output functions.  When

   232    inflateBack() needs more input, it calls in().  When inflateBack() has

   233    filled the window with output, or when it completes with data in the

   234    window, it calls out() to write out the data.  The application must not

   235    change the provided input until in() is called again or inflateBack()

   236    returns.  The application must not change the window/output buffer until

   237    inflateBack() returns.

   238 

   239    in() and out() are called with a descriptor parameter provided in the

   240    inflateBack() call.  This parameter can be a structure that provides the

   241    information required to do the read or write, as well as accumulated

   242    information on the input and output such as totals and check values.

   243 

   244    in() should return zero on failure.  out() should return non-zero on

   245    failure.  If either in() or out() fails, than inflateBack() returns a

   246    Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it

   247    was in() or out() that caused in the error.  Otherwise,  inflateBack()

   248    returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format

   249    error, or Z_MEM_ERROR if it could not allocate memory for the state.

   250    inflateBack() can also return Z_STREAM_ERROR if the input parameters

   251    are not correct, i.e. strm is Z_NULL or the state was not initialized.

   252  */

   253 

   254 #ifdef __SYMBIAN32__

   255 EXPORT_C int inflateBack_r(z_streamp strm,in_func  in, void FAR * in_desc,out_func  out,void FAR * out_desc)

   256 #else

   257 int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)

   258 z_streamp strm;

   259 in_func in;

   260 void FAR *in_desc;

   261 out_func out;

   262 void FAR *out_desc;

   263 #endif //__SYMBIAN32__

   264 {

   265     struct inflate_state FAR *state;

   266     unsigned char FAR *next;    /* next input */

   267     unsigned char FAR *put;     /* next output */

   268     unsigned have, left;        /* available input and output */

   269     unsigned long hold;         /* bit buffer */

   270     unsigned bits;              /* bits in bit buffer */

   271     unsigned copy;              /* number of stored or match bytes to copy */

   272     unsigned char FAR *from;    /* where to copy match bytes from */

   273     

   274 /*  Need to replace "this" variable with "current" as "this" is a reserved 

   275  *  keyword in C++ which is prefectly fine for a c code. As this file

   276  *  has been changed to C++ "this" needs to be changed.

   277  */ 

   278 #   define this current      

   279     code this;                  /* current decoding table entry */

   280     code last;                  /* parent table entry */

   281     unsigned len;               /* length to copy for repeats, bits to drop */

   282     int ret;                    /* return code */

   283     static const unsigned short order[19] = /* permutation of code lengths */

   284         {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};

   285 

   286     /* Check that the strm exists and that the state was initialized */

   287     if (strm == Z_NULL || strm->state == Z_NULL)

   288         return Z_STREAM_ERROR;

   289     state = (struct inflate_state FAR *)strm->state;

   290 

   291     /* Reset the state */

   292     strm->msg = Z_NULL;

   293     state->mode = TYPE;

   294     state->last = 0;

   295     state->whave = 0;

   296     next = strm->next_in;

   297     have = next != Z_NULL ? strm->avail_in : 0;

   298     hold = 0;

   299     bits = 0;

   300     put = state->window;

   301     left = state->wsize;

   302 

   303     /* Inflate until end of block marked as last */

   304     for (;;)

   305         switch (state->mode) {

   306         case TYPE:

   307             /* determine and dispatch block type */

   308             if (state->last) {

   309                 BYTEBITS();

   310                 state->mode = DONE;

   311                 break;

   312             }

   313             NEEDBITS(3);

   314             state->last = BITS(1);

   315             DROPBITS(1);

   316             switch (BITS(2)) {

   317             case 0:                             /* stored block */

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

   319                         state->last ? " (last)" : ""));

   320                 state->mode = STORED;

   321                 break;

   322             case 1:                             /* fixed block */

   323                 fixedtables(state);

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

   325                         state->last ? " (last)" : ""));

   326                 state->mode = LEN;              /* decode codes */

   327                 break;

   328             case 2:                             /* dynamic block */

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

   330                         state->last ? " (last)" : ""));

   331                 state->mode = TABLE;

   332                 break;

   333             case 3:

   334                 strm->msg = (char *)"invalid block type";

   335                 state->mode = BAD;

   336             }

   337             DROPBITS(2);

   338             break;

   339 

   340         case STORED:

   341             /* get and verify stored block length */

   342             BYTEBITS();                         /* go to byte boundary */

   343             NEEDBITS(32);

   344             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {

   345                 strm->msg = (char *)"invalid stored block lengths";

   346                 state->mode = BAD;

   347                 break;

   348             }

   349             state->length = (unsigned)hold & 0xffff;

   350             Tracev((stderr, "inflate:       stored length %u\n",

   351                     state->length));

   352             INITBITS();

   353 

   354             /* copy stored block from input to output */

   355             while (state->length != 0) {

   356                 copy = state->length;

   357                 PULL();

   358                 ROOM();

   359                 if (copy > have) copy = have;

   360                 if (copy > left) copy = left;

   361                 zmemcpy(put, next, copy);

   362                 have -= copy;

   363                 next += copy;

   364                 left -= copy;

   365                 put += copy;

   366                 state->length -= copy;

   367             }

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

   369             state->mode = TYPE;

   370             break;

   371 

   372         case TABLE:

   373             /* get dynamic table entries descriptor */

   374             NEEDBITS(14);

   375             state->nlen = BITS(5) + 257;

   376             DROPBITS(5);

   377             state->ndist = BITS(5) + 1;

   378             DROPBITS(5);

   379             state->ncode = BITS(4) + 4;

   380             DROPBITS(4);

   381 #ifndef PKZIP_BUG_WORKAROUND

   382             if (state->nlen > 286 || state->ndist > 30) {

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

   384                 state->mode = BAD;

   385                 break;

   386             }

   387 #endif

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

   389 

   390             /* get code length code lengths (not a typo) */

   391             state->have = 0;

   392             while (state->have < state->ncode) {

   393                 NEEDBITS(3);

   394                 state->lens[order[state->have++]] = (unsigned short)BITS(3);

   395                 DROPBITS(3);

   396             }

   397             while (state->have < 19)

   398                 state->lens[order[state->have++]] = 0;

   399             state->next = state->codes;

   400             state->lencode = (code const FAR *)(state->next);

   401             state->lenbits = 7;

   402             ret = inflate_table(CODES, state->lens, 19, &(state->next),

   403                                 &(state->lenbits), state->work);

   404             if (ret) {

   405                 strm->msg = (char *)"invalid code lengths set";

   406                 state->mode = BAD;

   407                 break;

   408             }

   409             Tracev((stderr, "inflate:       code lengths ok\n"));

   410 

   411             /* get length and distance code code lengths */

   412             state->have = 0;

   413             while (state->have < state->nlen + state->ndist) {

   414                 for (;;) {

   415                     this = state->lencode[BITS(state->lenbits)];

   416                     if ((unsigned)(this.bits) <= bits) break;

   417                     PULLBYTE();

   418                 }

   419                 if (this.val < 16) {

   420                     NEEDBITS(this.bits);

   421                     DROPBITS(this.bits);

   422                     state->lens[state->have++] = this.val;

   423                 }

   424                 else {

   425                     if (this.val == 16) {

   426                         NEEDBITS(this.bits + 2);

   427                         DROPBITS(this.bits);

   428                         if (state->have == 0) {

   429                             strm->msg = (char *)"invalid bit length repeat";

   430                             state->mode = BAD;

   431                             break;

   432                         }

   433                         len = (unsigned)(state->lens[state->have - 1]);

   434                         copy = 3 + BITS(2);

   435                         DROPBITS(2);

   436                     }

   437                     else if (this.val == 17) {

   438                         NEEDBITS(this.bits + 3);

   439                         DROPBITS(this.bits);

   440                         len = 0;

   441                         copy = 3 + BITS(3);

   442                         DROPBITS(3);

   443                     }

   444                     else {

   445                         NEEDBITS(this.bits + 7);

   446                         DROPBITS(this.bits);

   447                         len = 0;

   448                         copy = 11 + BITS(7);

   449                         DROPBITS(7);

   450                     }

   451                     if (state->have + copy > state->nlen + state->ndist) {

   452                         strm->msg = (char *)"invalid bit length repeat";

   453                         state->mode = BAD;

   454                         break;

   455                     }

   456                     while (copy--)

   457                         state->lens[state->have++] = (unsigned short)len;

   458                 }

   459             }

   460 

   461             /* handle error breaks in while */

   462             if (state->mode == BAD) break;

   463 

   464             /* build code tables */

   465             state->next = state->codes;

   466             state->lencode = (code const FAR *)(state->next);

   467             state->lenbits = 9;

   468             ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),

   469                                 &(state->lenbits), state->work);

   470             if (ret) {

   471                 strm->msg = (char *)"invalid literal/lengths set";

   472                 state->mode = BAD;

   473                 break;

   474             }

   475             state->distcode = (code const FAR *)(state->next);

   476             state->distbits = 6;

   477             ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,

   478                             &(state->next), &(state->distbits), state->work);

   479             if (ret) {

   480                 strm->msg = (char *)"invalid distances set";

   481                 state->mode = BAD;

   482                 break;

   483             }

   484             Tracev((stderr, "inflate:       codes ok\n"));

   485             state->mode = LEN;

   486 

   487         case LEN:

   488             /* use inflate_fast() if we have enough input and output */

   489             if (have >= 6 && left >= 258) {

   490                 RESTORE();

   491                 if (state->whave < state->wsize)

   492                     state->whave = state->wsize - left;

   493                 inflate_fast(strm, state->wsize);

   494                 LOAD();

   495                 break;

   496             }

   497 

   498             /* get a literal, length, or end-of-block code */

   499             for (;;) {

   500                 this = state->lencode[BITS(state->lenbits)];

   501                 if ((unsigned)(this.bits) <= bits) break;

   502                 PULLBYTE();

   503             }

   504             if (this.op && (this.op & 0xf0) == 0) {

   505                 last = this;

   506                 for (;;) {

   507                     this = state->lencode[last.val +

   508                             (BITS(last.bits + last.op) >> last.bits)];

   509                     if ((unsigned)(last.bits + this.bits) <= bits) break;

   510                     PULLBYTE();

   511                 }

   512                 DROPBITS(last.bits);

   513             }

   514             DROPBITS(this.bits);

   515             state->length = (unsigned)this.val;

   516 

   517             /* process literal */

   518             if (this.op == 0) {

   519                 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?

   520                         "inflate:         literal '%c'\n" :

   521                         "inflate:         literal 0x%02x\n", this.val));

   522                 ROOM();

   523                 *put++ = (unsigned char)(state->length);

   524                 left--;

   525                 state->mode = LEN;

   526                 break;

   527             }

   528 

   529             /* process end of block */

   530             if (this.op & 32) {

   531                 Tracevv((stderr, "inflate:         end of block\n"));

   532                 state->mode = TYPE;

   533                 break;

   534             }

   535 

   536             /* invalid code */

   537             if (this.op & 64) {

   538                 strm->msg = (char *)"invalid literal/length code";

   539                 state->mode = BAD;

   540                 break;

   541             }

   542 

   543             /* length code -- get extra bits, if any */

   544             state->extra = (unsigned)(this.op) & 15;

   545             if (state->extra != 0) {

   546                 NEEDBITS(state->extra);

   547                 state->length += BITS(state->extra);

   548                 DROPBITS(state->extra);

   549             }

   550             Tracevv((stderr, "inflate:         length %u\n", state->length));

   551 

   552             /* get distance code */

   553             for (;;) {

   554                 this = state->distcode[BITS(state->distbits)];

   555                 if ((unsigned)(this.bits) <= bits) break;

   556                 PULLBYTE();

   557             }

   558             if ((this.op & 0xf0) == 0) {

   559                 last = this;

   560                 for (;;) {

   561                     this = state->distcode[last.val +

   562                             (BITS(last.bits + last.op) >> last.bits)];

   563                     if ((unsigned)(last.bits + this.bits) <= bits) break;

   564                     PULLBYTE();

   565                 }

   566                 DROPBITS(last.bits);

   567             }

   568             DROPBITS(this.bits);

   569             if (this.op & 64) {

   570                 strm->msg = (char *)"invalid distance code";

   571                 state->mode = BAD;

   572                 break;

   573             }

   574             state->offset = (unsigned)this.val;

   575 

   576             /* get distance extra bits, if any */

   577             state->extra = (unsigned)(this.op) & 15;

   578             if (state->extra != 0) {

   579                 NEEDBITS(state->extra);

   580                 state->offset += BITS(state->extra);

   581                 DROPBITS(state->extra);

   582             }

   583             if (state->offset > state->wsize - (state->whave < state->wsize ?

   584                                                 left : 0)) {

   585                 strm->msg = (char *)"invalid distance too far back";

   586                 state->mode = BAD;

   587                 break;

   588             }

   589             Tracevv((stderr, "inflate:         distance %u\n", state->offset));

   590 

   591             /* copy match from window to output */

   592             do {

   593                 ROOM();

   594                 copy = state->wsize - state->offset;

   595                 if (copy < left) {

   596                     from = put + copy;

   597                     copy = left - copy;

   598                 }

   599                 else {

   600                     from = put - state->offset;

   601                     copy = left;

   602                 }

   603                 if (copy > state->length) copy = state->length;

   604                 state->length -= copy;

   605                 left -= copy;

   606                 do {

   607                     *put++ = *from++;

   608                 } while (--copy);

   609             } while (state->length != 0);

   610             break;

   611 

   612         case DONE:

   613             /* inflate stream terminated properly -- write leftover output */

   614             ret = Z_STREAM_END;

   615             if (left < state->wsize) {

   616                 if (out(out_desc, state->window, state->wsize - left))

   617                     ret = Z_BUF_ERROR;

   618             }

   619             goto inf_leave;

   620 

   621         case BAD:

   622             ret = Z_DATA_ERROR;

   623             goto inf_leave;

   624 

   625         default:                /* can't happen, but makes compilers happy */

   626             ret = Z_STREAM_ERROR;

   627             goto inf_leave;

   628         }

   629 

   630     /* Return unused input */

   631   inf_leave:

   632     strm->next_in = next;

   633     strm->avail_in = have;

   634     return ret;

   635 }

   636 

   637 

   638 #ifdef __SYMBIAN32__

   639 EXPORT_C int  inflateBackEnd_r(z_streamp strm)

   640 #else

   641 int ZEXPORT inflateBackEnd(strm)

   642 z_streamp strm;

   643  #endif //__SYMBIAN32__

   644 {

   645     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)

   646         return Z_STREAM_ERROR;

   647     ZFREE(strm, strm->state);

   648     strm->state = Z_NULL;

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

   650     return Z_OK;

   651 }