Home | History | Annotate | Download | only in zlib
      1 /* gzread.c -- zlib functions for reading gzip files
      2  * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
      3  * For conditions of distribution and use, see copyright notice in zlib.h
      4  */
      5 
      6 #include "gzguts.h"
      7 
      8 /* Local functions */
      9 local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
     10 local int gz_avail OF((gz_statep));
     11 local int gz_look OF((gz_statep));
     12 local int gz_decomp OF((gz_statep));
     13 local int gz_fetch OF((gz_statep));
     14 local int gz_skip OF((gz_statep, z_off64_t));
     15 
     16 /* Use read() to load a buffer -- return -1 on error, otherwise 0.  Read from
     17    state->fd, and update state->eof, state->err, and state->msg as appropriate.
     18    This function needs to loop on read(), since read() is not guaranteed to
     19    read the number of bytes requested, depending on the type of descriptor. */
     20 local int gz_load(state, buf, len, have)
     21     gz_statep state;
     22     unsigned char *buf;
     23     unsigned len;
     24     unsigned *have;
     25 {
     26     int ret;
     27 
     28     *have = 0;
     29     do {
     30         ret = read(state->fd, buf + *have, len - *have);
     31         if (ret <= 0)
     32             break;
     33         *have += ret;
     34     } while (*have < len);
     35     if (ret < 0) {
     36         gz_error(state, Z_ERRNO, zstrerror());
     37         return -1;
     38     }
     39     if (ret == 0)
     40         state->eof = 1;
     41     return 0;
     42 }
     43 
     44 /* Load up input buffer and set eof flag if last data loaded -- return -1 on
     45    error, 0 otherwise.  Note that the eof flag is set when the end of the input
     46    file is reached, even though there may be unused data in the buffer.  Once
     47    that data has been used, no more attempts will be made to read the file.
     48    If strm->avail_in != 0, then the current data is moved to the beginning of
     49    the input buffer, and then the remainder of the buffer is loaded with the
     50    available data from the input file. */
     51 local int gz_avail(state)
     52     gz_statep state;
     53 {
     54     unsigned got;
     55     z_streamp strm = &(state->strm);
     56 
     57     if (state->err != Z_OK && state->err != Z_BUF_ERROR)
     58         return -1;
     59     if (state->eof == 0) {
     60         if (strm->avail_in) {       /* copy what's there to the start */
     61             unsigned char *p = state->in;
     62             unsigned const char *q = strm->next_in;
     63             unsigned n = strm->avail_in;
     64             do {
     65                 *p++ = *q++;
     66             } while (--n);
     67         }
     68         if (gz_load(state, state->in + strm->avail_in,
     69                     state->size - strm->avail_in, &got) == -1)
     70             return -1;
     71         strm->avail_in += got;
     72         strm->next_in = state->in;
     73     }
     74     return 0;
     75 }
     76 
     77 /* Look for gzip header, set up for inflate or copy.  state->x.have must be 0.
     78    If this is the first time in, allocate required memory.  state->how will be
     79    left unchanged if there is no more input data available, will be set to COPY
     80    if there is no gzip header and direct copying will be performed, or it will
     81    be set to GZIP for decompression.  If direct copying, then leftover input
     82    data from the input buffer will be copied to the output buffer.  In that
     83    case, all further file reads will be directly to either the output buffer or
     84    a user buffer.  If decompressing, the inflate state will be initialized.
     85    gz_look() will return 0 on success or -1 on failure. */
     86 local int gz_look(state)
     87     gz_statep state;
     88 {
     89     z_streamp strm = &(state->strm);
     90 
     91     /* allocate read buffers and inflate memory */
     92     if (state->size == 0) {
     93         /* allocate buffers */
     94         state->in = (unsigned char *)malloc(state->want);
     95         state->out = (unsigned char *)malloc(state->want << 1);
     96         if (state->in == NULL || state->out == NULL) {
     97             if (state->out != NULL)
     98                 free(state->out);
     99             if (state->in != NULL)
    100                 free(state->in);
    101             gz_error(state, Z_MEM_ERROR, "out of memory");
    102             return -1;
    103         }
    104         state->size = state->want;
    105 
    106         /* allocate inflate memory */
    107         state->strm.zalloc = Z_NULL;
    108         state->strm.zfree = Z_NULL;
    109         state->strm.opaque = Z_NULL;
    110         state->strm.avail_in = 0;
    111         state->strm.next_in = Z_NULL;
    112         if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) {    /* gunzip */
    113             free(state->out);
    114             free(state->in);
    115             state->size = 0;
    116             gz_error(state, Z_MEM_ERROR, "out of memory");
    117             return -1;
    118         }
    119     }
    120 
    121     /* get at least the magic bytes in the input buffer */
    122     if (strm->avail_in < 2) {
    123         if (gz_avail(state) == -1)
    124             return -1;
    125         if (strm->avail_in == 0)
    126             return 0;
    127     }
    128 
    129     /* look for gzip magic bytes -- if there, do gzip decoding (note: there is
    130        a logical dilemma here when considering the case of a partially written
    131        gzip file, to wit, if a single 31 byte is written, then we cannot tell
    132        whether this is a single-byte file, or just a partially written gzip
    133        file -- for here we assume that if a gzip file is being written, then
    134        the header will be written in a single operation, so that reading a
    135        single byte is sufficient indication that it is not a gzip file) */
    136     if (strm->avail_in > 1 &&
    137             strm->next_in[0] == 31 && strm->next_in[1] == 139) {
    138         inflateReset(strm);
    139         state->how = GZIP;
    140         state->direct = 0;
    141         return 0;
    142     }
    143 
    144     /* no gzip header -- if we were decoding gzip before, then this is trailing
    145        garbage.  Ignore the trailing garbage and finish. */
    146     if (state->direct == 0) {
    147         strm->avail_in = 0;
    148         state->eof = 1;
    149         state->x.have = 0;
    150         return 0;
    151     }
    152 
    153     /* doing raw i/o, copy any leftover input to output -- this assumes that
    154        the output buffer is larger than the input buffer, which also assures
    155        space for gzungetc() */
    156     state->x.next = state->out;
    157     if (strm->avail_in) {
    158         memcpy(state->x.next, strm->next_in, strm->avail_in);
    159         state->x.have = strm->avail_in;
    160         strm->avail_in = 0;
    161     }
    162     state->how = COPY;
    163     state->direct = 1;
    164     return 0;
    165 }
    166 
    167 /* Decompress from input to the provided next_out and avail_out in the state.
    168    On return, state->x.have and state->x.next point to the just decompressed
    169    data.  If the gzip stream completes, state->how is reset to LOOK to look for
    170    the next gzip stream or raw data, once state->x.have is depleted.  Returns 0
    171    on success, -1 on failure. */
    172 local int gz_decomp(state)
    173     gz_statep state;
    174 {
    175     int ret = Z_OK;
    176     unsigned had;
    177     z_streamp strm = &(state->strm);
    178 
    179     /* fill output buffer up to end of deflate stream */
    180     had = strm->avail_out;
    181     do {
    182         /* get more input for inflate() */
    183         if (strm->avail_in == 0 && gz_avail(state) == -1)
    184             return -1;
    185         if (strm->avail_in == 0) {
    186             gz_error(state, Z_BUF_ERROR, "unexpected end of file");
    187             break;
    188         }
    189 
    190         /* decompress and handle errors */
    191         ret = inflate(strm, Z_NO_FLUSH);
    192         if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
    193             gz_error(state, Z_STREAM_ERROR,
    194                      "internal error: inflate stream corrupt");
    195             return -1;
    196         }
    197         if (ret == Z_MEM_ERROR) {
    198             gz_error(state, Z_MEM_ERROR, "out of memory");
    199             return -1;
    200         }
    201         if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
    202             gz_error(state, Z_DATA_ERROR,
    203                      strm->msg == NULL ? "compressed data error" : strm->msg);
    204             return -1;
    205         }
    206     } while (strm->avail_out && ret != Z_STREAM_END);
    207 
    208     /* update available output */
    209     state->x.have = had - strm->avail_out;
    210     state->x.next = strm->next_out - state->x.have;
    211 
    212     /* if the gzip stream completed successfully, look for another */
    213     if (ret == Z_STREAM_END)
    214         state->how = LOOK;
    215 
    216     /* good decompression */
    217     return 0;
    218 }
    219 
    220 /* Fetch data and put it in the output buffer.  Assumes state->x.have is 0.
    221    Data is either copied from the input file or decompressed from the input
    222    file depending on state->how.  If state->how is LOOK, then a gzip header is
    223    looked for to determine whether to copy or decompress.  Returns -1 on error,
    224    otherwise 0.  gz_fetch() will leave state->how as COPY or GZIP unless the
    225    end of the input file has been reached and all data has been processed.  */
    226 local int gz_fetch(state)
    227     gz_statep state;
    228 {
    229     z_streamp strm = &(state->strm);
    230 
    231     do {
    232         switch(state->how) {
    233         case LOOK:      /* -> LOOK, COPY (only if never GZIP), or GZIP */
    234             if (gz_look(state) == -1)
    235                 return -1;
    236             if (state->how == LOOK)
    237                 return 0;
    238             break;
    239         case COPY:      /* -> COPY */
    240             if (gz_load(state, state->out, state->size << 1, &(state->x.have))
    241                     == -1)
    242                 return -1;
    243             state->x.next = state->out;
    244             return 0;
    245         case GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */
    246             strm->avail_out = state->size << 1;
    247             strm->next_out = state->out;
    248             if (gz_decomp(state) == -1)
    249                 return -1;
    250         }
    251     } while (state->x.have == 0 && (!state->eof || strm->avail_in));
    252     return 0;
    253 }
    254 
    255 /* Skip len uncompressed bytes of output.  Return -1 on error, 0 on success. */
    256 local int gz_skip(state, len)
    257     gz_statep state;
    258     z_off64_t len;
    259 {
    260     unsigned n;
    261 
    262     /* skip over len bytes or reach end-of-file, whichever comes first */
    263     while (len)
    264         /* skip over whatever is in output buffer */
    265         if (state->x.have) {
    266             n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
    267                 (unsigned)len : state->x.have;
    268             state->x.have -= n;
    269             state->x.next += n;
    270             state->x.pos += n;
    271             len -= n;
    272         }
    273 
    274         /* output buffer empty -- return if we're at the end of the input */
    275         else if (state->eof && state->strm.avail_in == 0)
    276             break;
    277 
    278         /* need more data to skip -- load up output buffer */
    279         else {
    280             /* get more output, looking for header if required */
    281             if (gz_fetch(state) == -1)
    282                 return -1;
    283         }
    284     return 0;
    285 }
    286 
    287 /* -- see zlib.h -- */
    288 int ZEXPORT gzread(file, buf, len)
    289     gzFile file;
    290     voidp buf;
    291     unsigned len;
    292 {
    293     unsigned got, n;
    294     gz_statep state;
    295     z_streamp strm;
    296 
    297     /* get internal structure */
    298     if (file == NULL)
    299         return -1;
    300     state = (gz_statep)file;
    301     strm = &(state->strm);
    302 
    303     /* check that we're reading and that there's no (serious) error */
    304     if (state->mode != GZ_READ ||
    305             (state->err != Z_OK && state->err != Z_BUF_ERROR))
    306         return -1;
    307 
    308     /* since an int is returned, make sure len fits in one, otherwise return
    309        with an error (this avoids the flaw in the interface) */
    310     if ((int)len < 0) {
    311         gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
    312         return -1;
    313     }
    314 
    315     /* if len is zero, avoid unnecessary operations */
    316     if (len == 0)
    317         return 0;
    318 
    319     /* process a skip request */
    320     if (state->seek) {
    321         state->seek = 0;
    322         if (gz_skip(state, state->skip) == -1)
    323             return -1;
    324     }
    325 
    326     /* get len bytes to buf, or less than len if at the end */
    327     got = 0;
    328     do {
    329         /* first just try copying data from the output buffer */
    330         if (state->x.have) {
    331             n = state->x.have > len ? len : state->x.have;
    332             memcpy(buf, state->x.next, n);
    333             state->x.next += n;
    334             state->x.have -= n;
    335         }
    336 
    337         /* output buffer empty -- return if we're at the end of the input */
    338         else if (state->eof && strm->avail_in == 0) {
    339             state->past = 1;        /* tried to read past end */
    340             break;
    341         }
    342 
    343         /* need output data -- for small len or new stream load up our output
    344            buffer */
    345         else if (state->how == LOOK || len < (state->size << 1)) {
    346             /* get more output, looking for header if required */
    347             if (gz_fetch(state) == -1)
    348                 return -1;
    349             continue;       /* no progress yet -- go back to copy above */
    350             /* the copy above assures that we will leave with space in the
    351                output buffer, allowing at least one gzungetc() to succeed */
    352         }
    353 
    354         /* large len -- read directly into user buffer */
    355         else if (state->how == COPY) {      /* read directly */
    356             if (gz_load(state, (unsigned char *)buf, len, &n) == -1)
    357                 return -1;
    358         }
    359 
    360         /* large len -- decompress directly into user buffer */
    361         else {  /* state->how == GZIP */
    362             strm->avail_out = len;
    363             strm->next_out = (unsigned char *)buf;
    364             if (gz_decomp(state) == -1)
    365                 return -1;
    366             n = state->x.have;
    367             state->x.have = 0;
    368         }
    369 
    370         /* update progress */
    371         len -= n;
    372         buf = (char *)buf + n;
    373         got += n;
    374         state->x.pos += n;
    375     } while (len);
    376 
    377     /* return number of bytes read into user buffer (will fit in int) */
    378     return (int)got;
    379 }
    380 
    381 /* -- see zlib.h -- */
    382 #ifdef Z_PREFIX_SET
    383 #  undef z_gzgetc
    384 #else
    385 #  undef gzgetc
    386 #endif
    387 int ZEXPORT gzgetc(file)
    388     gzFile file;
    389 {
    390     int ret;
    391     unsigned char buf[1];
    392     gz_statep state;
    393 
    394     /* get internal structure */
    395     if (file == NULL)
    396         return -1;
    397     state = (gz_statep)file;
    398 
    399     /* check that we're reading and that there's no (serious) error */
    400     if (state->mode != GZ_READ ||
    401         (state->err != Z_OK && state->err != Z_BUF_ERROR))
    402         return -1;
    403 
    404     /* try output buffer (no need to check for skip request) */
    405     if (state->x.have) {
    406         state->x.have--;
    407         state->x.pos++;
    408         return *(state->x.next)++;
    409     }
    410 
    411     /* nothing there -- try gzread() */
    412     ret = gzread(file, buf, 1);
    413     return ret < 1 ? -1 : buf[0];
    414 }
    415 
    416 int ZEXPORT gzgetc_(file)
    417 gzFile file;
    418 {
    419     return gzgetc(file);
    420 }
    421 
    422 /* -- see zlib.h -- */
    423 int ZEXPORT gzungetc(c, file)
    424     int c;
    425     gzFile file;
    426 {
    427     gz_statep state;
    428 
    429     /* get internal structure */
    430     if (file == NULL)
    431         return -1;
    432     state = (gz_statep)file;
    433 
    434     /* check that we're reading and that there's no (serious) error */
    435     if (state->mode != GZ_READ ||
    436         (state->err != Z_OK && state->err != Z_BUF_ERROR))
    437         return -1;
    438 
    439     /* process a skip request */
    440     if (state->seek) {
    441         state->seek = 0;
    442         if (gz_skip(state, state->skip) == -1)
    443             return -1;
    444     }
    445 
    446     /* can't push EOF */
    447     if (c < 0)
    448         return -1;
    449 
    450     /* if output buffer empty, put byte at end (allows more pushing) */
    451     if (state->x.have == 0) {
    452         state->x.have = 1;
    453         state->x.next = state->out + (state->size << 1) - 1;
    454         state->x.next[0] = c;
    455         state->x.pos--;
    456         state->past = 0;
    457         return c;
    458     }
    459 
    460     /* if no room, give up (must have already done a gzungetc()) */
    461     if (state->x.have == (state->size << 1)) {
    462         gz_error(state, Z_DATA_ERROR, "out of room to push characters");
    463         return -1;
    464     }
    465 
    466     /* slide output data if needed and insert byte before existing data */
    467     if (state->x.next == state->out) {
    468         unsigned char *src = state->out + state->x.have;
    469         unsigned char *dest = state->out + (state->size << 1);
    470         while (src > state->out)
    471             *--dest = *--src;
    472         state->x.next = dest;
    473     }
    474     state->x.have++;
    475     state->x.next--;
    476     state->x.next[0] = c;
    477     state->x.pos--;
    478     state->past = 0;
    479     return c;
    480 }
    481 
    482 /* -- see zlib.h -- */
    483 char * ZEXPORT gzgets(file, buf, len)
    484     gzFile file;
    485     char *buf;
    486     int len;
    487 {
    488     unsigned left, n;
    489     char *str;
    490     unsigned char *eol;
    491     gz_statep state;
    492 
    493     /* check parameters and get internal structure */
    494     if (file == NULL || buf == NULL || len < 1)
    495         return NULL;
    496     state = (gz_statep)file;
    497 
    498     /* check that we're reading and that there's no (serious) error */
    499     if (state->mode != GZ_READ ||
    500         (state->err != Z_OK && state->err != Z_BUF_ERROR))
    501         return NULL;
    502 
    503     /* process a skip request */
    504     if (state->seek) {
    505         state->seek = 0;
    506         if (gz_skip(state, state->skip) == -1)
    507             return NULL;
    508     }
    509 
    510     /* copy output bytes up to new line or len - 1, whichever comes first --
    511        append a terminating zero to the string (we don't check for a zero in
    512        the contents, let the user worry about that) */
    513     str = buf;
    514     left = (unsigned)len - 1;
    515     if (left) do {
    516         /* assure that something is in the output buffer */
    517         if (state->x.have == 0 && gz_fetch(state) == -1)
    518             return NULL;                /* error */
    519         if (state->x.have == 0) {       /* end of file */
    520             state->past = 1;            /* read past end */
    521             break;                      /* return what we have */
    522         }
    523 
    524         /* look for end-of-line in current output buffer */
    525         n = state->x.have > left ? left : state->x.have;
    526         eol = (unsigned char *)memchr(state->x.next, '\n', n);
    527         if (eol != NULL)
    528             n = (unsigned)(eol - state->x.next) + 1;
    529 
    530         /* copy through end-of-line, or remainder if not found */
    531         memcpy(buf, state->x.next, n);
    532         state->x.have -= n;
    533         state->x.next += n;
    534         state->x.pos += n;
    535         left -= n;
    536         buf += n;
    537     } while (left && eol == NULL);
    538 
    539     /* return terminated string, or if nothing, end of file */
    540     if (buf == str)
    541         return NULL;
    542     buf[0] = 0;
    543     return str;
    544 }
    545 
    546 /* -- see zlib.h -- */
    547 int ZEXPORT gzdirect(file)
    548     gzFile file;
    549 {
    550     gz_statep state;
    551 
    552     /* get internal structure */
    553     if (file == NULL)
    554         return 0;
    555     state = (gz_statep)file;
    556 
    557     /* if the state is not known, but we can find out, then do so (this is
    558        mainly for right after a gzopen() or gzdopen()) */
    559     if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
    560         (void)gz_look(state);
    561 
    562     /* return 1 if transparent, 0 if processing a gzip stream */
    563     return state->direct;
    564 }
    565 
    566 /* -- see zlib.h -- */
    567 int ZEXPORT gzclose_r(file)
    568     gzFile file;
    569 {
    570     int ret, err;
    571     gz_statep state;
    572 
    573     /* get internal structure */
    574     if (file == NULL)
    575         return Z_STREAM_ERROR;
    576     state = (gz_statep)file;
    577 
    578     /* check that we're reading */
    579     if (state->mode != GZ_READ)
    580         return Z_STREAM_ERROR;
    581 
    582     /* free memory and close file */
    583     if (state->size) {
    584         inflateEnd(&(state->strm));
    585         free(state->out);
    586         free(state->in);
    587     }
    588     err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
    589     gz_error(state, Z_OK, NULL);
    590     free(state->path);
    591     ret = close(state->fd);
    592     free(state);
    593     return ret ? Z_ERRNO : err;
    594 }
    595