"Fossies" - the Fresh Open Source Software Archive

Member "muscle/zlib/zlib/gzread.c" (21 Nov 2020, 20473 Bytes) of package /linux/privat/muscle7.62.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "gzread.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 7.61_vs_7.62.

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