1 /*

     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     3  *

     4  * This code is free software; you can redistribute it and/or modify it

     5  * under the terms of the GNU General Public License version 2 only, as

     6  * published by the Free Software Foundation.  Oracle designates this

     7  * particular file as subject to the "Classpath" exception as provided

     8  * by Oracle in the LICENSE file that accompanied this code.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  */

    24 

    25 /* gzread.c -- zlib functions for reading gzip files

    26  * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler

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

    28  */

    29 

    30 #include "gzguts.h"

    31 

    32 /* Local functions */

    33 local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));

    34 local int gz_avail OF((gz_statep));

    35 local int gz_look OF((gz_statep));

    36 local int gz_decomp OF((gz_statep));

    37 local int gz_fetch OF((gz_statep));

    38 local int gz_skip OF((gz_statep, z_off64_t));

    39 

    40 /* Use read() to load a buffer -- return -1 on error, otherwise 0.  Read from

    41    state->fd, and update state->eof, state->err, and state->msg as appropriate.

    42    This function needs to loop on read(), since read() is not guaranteed to

    43    read the number of bytes requested, depending on the type of descriptor. */

    44 local int gz_load(state, buf, len, have)

    45     gz_statep state;

    46     unsigned char *buf;

    47     unsigned len;

    48     unsigned *have;

    49 {

    50     int ret;

    51 

    52     *have = 0;

    53     do {

    54         ret = read(state->fd, buf + *have, len - *have);

    55         if (ret <= 0)

    56             break;

    57         *have += ret;

    58     } while (*have < len);

    59     if (ret < 0) {

    60         gz_error(state, Z_ERRNO, zstrerror());

    61         return -1;

    62     }

    63     if (ret == 0)

    64         state->eof = 1;

    65     return 0;

    66 }

    67 

    68 /* Load up input buffer and set eof flag if last data loaded -- return -1 on

    69    error, 0 otherwise.  Note that the eof flag is set when the end of the input

    70    file is reached, even though there may be unused data in the buffer.  Once

    71    that data has been used, no more attempts will be made to read the file.

    72    If strm->avail_in != 0, then the current data is moved to the beginning of

    73    the input buffer, and then the remainder of the buffer is loaded with the

    74    available data from the input file. */

    75 local int gz_avail(state)

    76     gz_statep state;

    77 {

    78     unsigned got;

    79     z_streamp strm = &(state->strm);

    80 

    81     if (state->err != Z_OK && state->err != Z_BUF_ERROR)

    82         return -1;

    83     if (state->eof == 0) {

    84         if (strm->avail_in) {       /* copy what's there to the start */

    85             unsigned char *p = state->in;

    86             unsigned const char *q = strm->next_in;

    87             unsigned n = strm->avail_in;

    88             do {

    89                 *p++ = *q++;

    90             } while (--n);

    91         }

    92         if (gz_load(state, state->in + strm->avail_in,

    93                     state->size - strm->avail_in, &got) == -1)

    94             return -1;

    95         strm->avail_in += got;

    96         strm->next_in = state->in;

    97     }

    98     return 0;

    99 }

   100 

   101 /* Look for gzip header, set up for inflate or copy.  state->x.have must be 0.

   102    If this is the first time in, allocate required memory.  state->how will be

   103    left unchanged if there is no more input data available, will be set to COPY

   104    if there is no gzip header and direct copying will be performed, or it will

   105    be set to GZIP for decompression.  If direct copying, then leftover input

   106    data from the input buffer will be copied to the output buffer.  In that

   107    case, all further file reads will be directly to either the output buffer or

   108    a user buffer.  If decompressing, the inflate state will be initialized.

   109    gz_look() will return 0 on success or -1 on failure. */

   110 local int gz_look(state)

   111     gz_statep state;

   112 {

   113     z_streamp strm = &(state->strm);

   114 

   115     /* allocate read buffers and inflate memory */

   116     if (state->size == 0) {

   117         /* allocate buffers */

   118         state->in = (unsigned char *)malloc(state->want);

   119         state->out = (unsigned char *)malloc(state->want << 1);

   120         if (state->in == NULL || state->out == NULL) {

   121             if (state->out != NULL)

   122                 free(state->out);

   123             if (state->in != NULL)

   124                 free(state->in);

   125             gz_error(state, Z_MEM_ERROR, "out of memory");

   126             return -1;

   127         }

   128         state->size = state->want;

   129 

   130         /* allocate inflate memory */

   131         state->strm.zalloc = Z_NULL;

   132         state->strm.zfree = Z_NULL;

   133         state->strm.opaque = Z_NULL;

   134         state->strm.avail_in = 0;

   135         state->strm.next_in = Z_NULL;

   136         if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) {    /* gunzip */

   137             free(state->out);

   138             free(state->in);

   139             state->size = 0;

   140             gz_error(state, Z_MEM_ERROR, "out of memory");

   141             return -1;

   142         }

   143     }

   144 

   145     /* get at least the magic bytes in the input buffer */

   146     if (strm->avail_in < 2) {

   147         if (gz_avail(state) == -1)

   148             return -1;

   149         if (strm->avail_in == 0)

   150             return 0;

   151     }

   152 

   153     /* look for gzip magic bytes -- if there, do gzip decoding (note: there is

   154        a logical dilemma here when considering the case of a partially written

   155        gzip file, to wit, if a single 31 byte is written, then we cannot tell

   156        whether this is a single-byte file, or just a partially written gzip

   157        file -- for here we assume that if a gzip file is being written, then

   158        the header will be written in a single operation, so that reading a

   159        single byte is sufficient indication that it is not a gzip file) */

   160     if (strm->avail_in > 1 &&

   161             strm->next_in[0] == 31 && strm->next_in[1] == 139) {

   162         inflateReset(strm);

   163         state->how = GZIP;

   164         state->direct = 0;

   165         return 0;

   166     }

   167 

   168     /* no gzip header -- if we were decoding gzip before, then this is trailing

   169        garbage.  Ignore the trailing garbage and finish. */

   170     if (state->direct == 0) {

   171         strm->avail_in = 0;

   172         state->eof = 1;

   173         state->x.have = 0;

   174         return 0;

   175     }

   176 

   177     /* doing raw i/o, copy any leftover input to output -- this assumes that

   178        the output buffer is larger than the input buffer, which also assures

   179        space for gzungetc() */

   180     state->x.next = state->out;

   181     if (strm->avail_in) {

   182         memcpy(state->x.next, strm->next_in, strm->avail_in);

   183         state->x.have = strm->avail_in;

   184         strm->avail_in = 0;

   185     }

   186     state->how = COPY;

   187     state->direct = 1;

   188     return 0;

   189 }

   190 

   191 /* Decompress from input to the provided next_out and avail_out in the state.

   192    On return, state->x.have and state->x.next point to the just decompressed

   193    data.  If the gzip stream completes, state->how is reset to LOOK to look for

   194    the next gzip stream or raw data, once state->x.have is depleted.  Returns 0

   195    on success, -1 on failure. */

   196 local int gz_decomp(state)

   197     gz_statep state;

   198 {

   199     int ret = Z_OK;

   200     unsigned had;

   201     z_streamp strm = &(state->strm);

   202 

   203     /* fill output buffer up to end of deflate stream */

   204     had = strm->avail_out;

   205     do {

   206         /* get more input for inflate() */

   207         if (strm->avail_in == 0 && gz_avail(state) == -1)

   208             return -1;

   209         if (strm->avail_in == 0) {

   210             gz_error(state, Z_BUF_ERROR, "unexpected end of file");

   211             break;

   212         }

   213 

   214         /* decompress and handle errors */

   215         ret = inflate(strm, Z_NO_FLUSH);

   216         if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {

   217             gz_error(state, Z_STREAM_ERROR,

   218                      "internal error: inflate stream corrupt");

   219             return -1;

   220         }

   221         if (ret == Z_MEM_ERROR) {

   222             gz_error(state, Z_MEM_ERROR, "out of memory");

   223             return -1;

   224         }

   225         if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */

   226             gz_error(state, Z_DATA_ERROR,

   227                      strm->msg == NULL ? "compressed data error" : strm->msg);

   228             return -1;

   229         }

   230     } while (strm->avail_out && ret != Z_STREAM_END);

   231 

   232     /* update available output */

   233     state->x.have = had - strm->avail_out;

   234     state->x.next = strm->next_out - state->x.have;

   235 

   236     /* if the gzip stream completed successfully, look for another */

   237     if (ret == Z_STREAM_END)

   238         state->how = LOOK;

   239 

   240     /* good decompression */

   241     return 0;

   242 }

   243 

   244 /* Fetch data and put it in the output buffer.  Assumes state->x.have is 0.

   245    Data is either copied from the input file or decompressed from the input

   246    file depending on state->how.  If state->how is LOOK, then a gzip header is

   247    looked for to determine whether to copy or decompress.  Returns -1 on error,

   248    otherwise 0.  gz_fetch() will leave state->how as COPY or GZIP unless the

   249    end of the input file has been reached and all data has been processed.  */

   250 local int gz_fetch(state)

   251     gz_statep state;

   252 {

   253     z_streamp strm = &(state->strm);

   254 

   255     do {

   256         switch(state->how) {

   257         case LOOK:      /* -> LOOK, COPY (only if never GZIP), or GZIP */

   258             if (gz_look(state) == -1)

   259                 return -1;

   260             if (state->how == LOOK)

   261                 return 0;

   262             break;

   263         case COPY:      /* -> COPY */

   264             if (gz_load(state, state->out, state->size << 1, &(state->x.have))

   265                     == -1)

   266                 return -1;

   267             state->x.next = state->out;

   268             return 0;

   269         case GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */

   270             strm->avail_out = state->size << 1;

   271             strm->next_out = state->out;

   272             if (gz_decomp(state) == -1)

   273                 return -1;

   274         }

   275     } while (state->x.have == 0 && (!state->eof || strm->avail_in));

   276     return 0;

   277 }

   278 

   279 /* Skip len uncompressed bytes of output.  Return -1 on error, 0 on success. */

   280 local int gz_skip(state, len)

   281     gz_statep state;

   282     z_off64_t len;

   283 {

   284     unsigned n;

   285 

   286     /* skip over len bytes or reach end-of-file, whichever comes first */

   287     while (len)

   288         /* skip over whatever is in output buffer */

   289         if (state->x.have) {

   290             n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?

   291                 (unsigned)len : state->x.have;

   292             state->x.have -= n;

   293             state->x.next += n;

   294             state->x.pos += n;

   295             len -= n;

   296         }

   297 

   298         /* output buffer empty -- return if we're at the end of the input */

   299         else if (state->eof && state->strm.avail_in == 0)

   300             break;

   301 

   302         /* need more data to skip -- load up output buffer */

   303         else {

   304             /* get more output, looking for header if required */

   305             if (gz_fetch(state) == -1)

   306                 return -1;

   307         }

   308     return 0;

   309 }

   310 

   311 /* -- see zlib.h -- */

   312 int ZEXPORT gzread(file, buf, len)

   313     gzFile file;

   314     voidp buf;

   315     unsigned len;

   316 {

   317     unsigned got, n;

   318     gz_statep state;

   319     z_streamp strm;

   320 

   321     /* get internal structure */

   322     if (file == NULL)

   323         return -1;

   324     state = (gz_statep)file;

   325     strm = &(state->strm);

   326 

   327     /* check that we're reading and that there's no (serious) error */

   328     if (state->mode != GZ_READ ||

   329             (state->err != Z_OK && state->err != Z_BUF_ERROR))

   330         return -1;

   331 

   332     /* since an int is returned, make sure len fits in one, otherwise return

   333        with an error (this avoids the flaw in the interface) */

   334     if ((int)len < 0) {

   335         gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");

   336         return -1;

   337     }

   338 

   339     /* if len is zero, avoid unnecessary operations */

   340     if (len == 0)

   341         return 0;

   342 

   343     /* process a skip request */

   344     if (state->seek) {

   345         state->seek = 0;

   346         if (gz_skip(state, state->skip) == -1)

   347             return -1;

   348     }

   349 

   350     /* get len bytes to buf, or less than len if at the end */

   351     got = 0;

   352     do {

   353         /* first just try copying data from the output buffer */

   354         if (state->x.have) {

   355             n = state->x.have > len ? len : state->x.have;

   356             memcpy(buf, state->x.next, n);

   357             state->x.next += n;

   358             state->x.have -= n;

   359         }

   360 

   361         /* output buffer empty -- return if we're at the end of the input */

   362         else if (state->eof && strm->avail_in == 0) {

   363             state->past = 1;        /* tried to read past end */

   364             break;

   365         }

   366 

   367         /* need output data -- for small len or new stream load up our output

   368            buffer */

   369         else if (state->how == LOOK || len < (state->size << 1)) {

   370             /* get more output, looking for header if required */

   371             if (gz_fetch(state) == -1)

   372                 return -1;

   373             continue;       /* no progress yet -- go back to copy above */

   374             /* the copy above assures that we will leave with space in the

   375                output buffer, allowing at least one gzungetc() to succeed */

   376         }

   377 

   378         /* large len -- read directly into user buffer */

   379         else if (state->how == COPY) {      /* read directly */

   380             if (gz_load(state, (unsigned char *)buf, len, &n) == -1)

   381                 return -1;

   382         }

   383 

   384         /* large len -- decompress directly into user buffer */

   385         else {  /* state->how == GZIP */

   386             strm->avail_out = len;

   387             strm->next_out = (unsigned char *)buf;

   388             if (gz_decomp(state) == -1)

   389                 return -1;

   390             n = state->x.have;

   391             state->x.have = 0;

   392         }

   393 

   394         /* update progress */

   395         len -= n;

   396         buf = (char *)buf + n;

   397         got += n;

   398         state->x.pos += n;

   399     } while (len);

   400 

   401     /* return number of bytes read into user buffer (will fit in int) */

   402     return (int)got;

   403 }

   404 

   405 /* -- see zlib.h -- */

   406 #ifdef Z_PREFIX_SET

   407 #  undef z_gzgetc

   408 #else

   409 #  undef gzgetc

   410 #endif

   411 int ZEXPORT gzgetc(file)

   412     gzFile file;

   413 {

   414     int ret;

   415     unsigned char buf[1];

   416     gz_statep state;

   417 

   418     /* get internal structure */

   419     if (file == NULL)

   420         return -1;

   421     state = (gz_statep)file;

   422 

   423     /* check that we're reading and that there's no (serious) error */

   424     if (state->mode != GZ_READ ||

   425         (state->err != Z_OK && state->err != Z_BUF_ERROR))

   426         return -1;

   427 

   428     /* try output buffer (no need to check for skip request) */

   429     if (state->x.have) {

   430         state->x.have--;

   431         state->x.pos++;

   432         return *(state->x.next)++;

   433     }

   434 

   435     /* nothing there -- try gzread() */

   436     ret = gzread(file, buf, 1);

   437     return ret < 1 ? -1 : buf[0];

   438 }

   439 

   440 int ZEXPORT gzgetc_(file)

   441 gzFile file;

   442 {

   443     return gzgetc(file);

   444 }

   445 

   446 /* -- see zlib.h -- */

   447 int ZEXPORT gzungetc(c, file)

   448     int c;

   449     gzFile file;

   450 {

   451     gz_statep state;

   452 

   453     /* get internal structure */

   454     if (file == NULL)

   455         return -1;

   456     state = (gz_statep)file;

   457 

   458     /* check that we're reading and that there's no (serious) error */

   459     if (state->mode != GZ_READ ||

   460         (state->err != Z_OK && state->err != Z_BUF_ERROR))

   461         return -1;

   462 

   463     /* process a skip request */

   464     if (state->seek) {

   465         state->seek = 0;

   466         if (gz_skip(state, state->skip) == -1)

   467             return -1;

   468     }

   469 

   470     /* can't push EOF */

   471     if (c < 0)

   472         return -1;

   473 

   474     /* if output buffer empty, put byte at end (allows more pushing) */

   475     if (state->x.have == 0) {

   476         state->x.have = 1;

   477         state->x.next = state->out + (state->size << 1) - 1;

   478         state->x.next[0] = c;

   479         state->x.pos--;

   480         state->past = 0;

   481         return c;

   482     }

   483 

   484     /* if no room, give up (must have already done a gzungetc()) */

   485     if (state->x.have == (state->size << 1)) {

   486         gz_error(state, Z_DATA_ERROR, "out of room to push characters");

   487         return -1;

   488     }

   489 

   490     /* slide output data if needed and insert byte before existing data */

   491     if (state->x.next == state->out) {

   492         unsigned char *src = state->out + state->x.have;

   493         unsigned char *dest = state->out + (state->size << 1);

   494         while (src > state->out)

   495             *--dest = *--src;

   496         state->x.next = dest;

   497     }

   498     state->x.have++;

   499     state->x.next--;

   500     state->x.next[0] = c;

   501     state->x.pos--;

   502     state->past = 0;

   503     return c;

   504 }

   505 

   506 /* -- see zlib.h -- */

   507 char * ZEXPORT gzgets(file, buf, len)

   508     gzFile file;

   509     char *buf;

   510     int len;

   511 {

   512     unsigned left, n;

   513     char *str;

   514     unsigned char *eol;

   515     gz_statep state;

   516 

   517     /* check parameters and get internal structure */

   518     if (file == NULL || buf == NULL || len < 1)

   519         return NULL;

   520     state = (gz_statep)file;

   521 

   522     /* check that we're reading and that there's no (serious) error */

   523     if (state->mode != GZ_READ ||

   524         (state->err != Z_OK && state->err != Z_BUF_ERROR))

   525         return NULL;

   526 

   527     /* process a skip request */

   528     if (state->seek) {

   529         state->seek = 0;

   530         if (gz_skip(state, state->skip) == -1)

   531             return NULL;

   532     }

   533 

   534     /* copy output bytes up to new line or len - 1, whichever comes first --

   535        append a terminating zero to the string (we don't check for a zero in

   536        the contents, let the user worry about that) */

   537     str = buf;

   538     left = (unsigned)len - 1;

   539     if (left) do {

   540         /* assure that something is in the output buffer */

   541         if (state->x.have == 0 && gz_fetch(state) == -1)

   542             return NULL;                /* error */

   543         if (state->x.have == 0) {       /* end of file */

   544             state->past = 1;            /* read past end */

   545             break;                      /* return what we have */

   546         }

   547 

   548         /* look for end-of-line in current output buffer */

   549         n = state->x.have > left ? left : state->x.have;

   550         eol = (unsigned char *)memchr(state->x.next, '\n', n);

   551         if (eol != NULL)

   552             n = (unsigned)(eol - state->x.next) + 1;

   553 

   554         /* copy through end-of-line, or remainder if not found */

   555         memcpy(buf, state->x.next, n);

   556         state->x.have -= n;

   557         state->x.next += n;

   558         state->x.pos += n;

   559         left -= n;

   560         buf += n;

   561     } while (left && eol == NULL);

   562 

   563     /* return terminated string, or if nothing, end of file */

   564     if (buf == str)

   565         return NULL;

   566     buf[0] = 0;

   567     return str;

   568 }

   569 

   570 /* -- see zlib.h -- */

   571 int ZEXPORT gzdirect(file)

   572     gzFile file;

   573 {

   574     gz_statep state;

   575 

   576     /* get internal structure */

   577     if (file == NULL)

   578         return 0;

   579     state = (gz_statep)file;

   580 

   581     /* if the state is not known, but we can find out, then do so (this is

   582        mainly for right after a gzopen() or gzdopen()) */

   583     if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)

   584         (void)gz_look(state);

   585 

   586     /* return 1 if transparent, 0 if processing a gzip stream */

   587     return state->direct;

   588 }

   589 

   590 /* -- see zlib.h -- */

   591 int ZEXPORT gzclose_r(file)

   592     gzFile file;

   593 {

   594     int ret, err;

   595     gz_statep state;

   596 

   597     /* get internal structure */

   598     if (file == NULL)

   599         return Z_STREAM_ERROR;

   600     state = (gz_statep)file;

   601 

   602     /* check that we're reading */

   603     if (state->mode != GZ_READ)

   604         return Z_STREAM_ERROR;

   605 

   606     /* free memory and close file */

   607     if (state->size) {

   608         inflateEnd(&(state->strm));

   609         free(state->out);

   610         free(state->in);

   611     }

   612     err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;

   613     gz_error(state, Z_OK, NULL);

   614     free(state->path);

   615     ret = close(state->fd);

   616     free(state);

   617     return ret ? Z_ERRNO : err;

   618 }