"Fossies" - the Fresh Open Source Software Archive

Member "muscle/zlib/zlib/examples/zran.c" (21 Nov 2020, 15438 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. See also the latest Fossies "Diffs" side-by-side code changes report for "zran.c": 7.61_vs_7.62.

    1 /* zran.c -- example of zlib/gzip stream indexing and random access
    2  * Copyright (C) 2005, 2012 Mark Adler
    3  * For conditions of distribution and use, see copyright notice in zlib.h
    4    Version 1.1  29 Sep 2012  Mark Adler */
    5 
    6 /* Version History:
    7  1.0  29 May 2005  First version
    8  1.1  29 Sep 2012  Fix memory reallocation error
    9  */
   10 
   11 /* Illustrate the use of Z_BLOCK, inflatePrime(), and inflateSetDictionary()
   12    for random access of a compressed file.  A file containing a zlib or gzip
   13    stream is provided on the command line.  The compressed stream is decoded in
   14    its entirety, and an index built with access points about every SPAN bytes
   15    in the uncompressed output.  The compressed file is left open, and can then
   16    be read randomly, having to decompress on the average SPAN/2 uncompressed
   17    bytes before getting to the desired block of data.
   18 
   19    An access point can be created at the start of any deflate block, by saving
   20    the starting file offset and bit of that block, and the 32K bytes of
   21    uncompressed data that precede that block.  Also the uncompressed offset of
   22    that block is saved to provide a referece for locating a desired starting
   23    point in the uncompressed stream.  build_index() works by decompressing the
   24    input zlib or gzip stream a block at a time, and at the end of each block
   25    deciding if enough uncompressed data has gone by to justify the creation of
   26    a new access point.  If so, that point is saved in a data structure that
   27    grows as needed to accommodate the points.
   28 
   29    To use the index, an offset in the uncompressed data is provided, for which
   30    the latest access point at or preceding that offset is located in the index.
   31    The input file is positioned to the specified location in the index, and if
   32    necessary the first few bits of the compressed data is read from the file.
   33    inflate is initialized with those bits and the 32K of uncompressed data, and
   34    the decompression then proceeds until the desired offset in the file is
   35    reached.  Then the decompression continues to read the desired uncompressed
   36    data from the file.
   37 
   38    Another approach would be to generate the index on demand.  In that case,
   39    requests for random access reads from the compressed data would try to use
   40    the index, but if a read far enough past the end of the index is required,
   41    then further index entries would be generated and added.
   42 
   43    There is some fair bit of overhead to starting inflation for the random
   44    access, mainly copying the 32K byte dictionary.  So if small pieces of the
   45    file are being accessed, it would make sense to implement a cache to hold
   46    some lookahead and avoid many calls to extract() for small lengths.
   47 
   48    Another way to build an index would be to use inflateCopy().  That would
   49    not be constrained to have access points at block boundaries, but requires
   50    more memory per access point, and also cannot be saved to file due to the
   51    use of pointers in the state.  The approach here allows for storage of the
   52    index in a file.
   53  */
   54 
   55 #include <stdio.h>
   56 #include <stdlib.h>
   57 #include <string.h>
   58 #include "zlib.h"
   59 
   60 #define local static
   61 
   62 #define SPAN 1048576L       /* desired distance between access points */
   63 #define WINSIZE 32768U      /* sliding window size */
   64 #define CHUNK 16384         /* file input buffer size */
   65 
   66 /* access point entry */
   67 struct point {
   68     off_t out;          /* corresponding offset in uncompressed data */
   69     off_t in;           /* offset in input file of first full byte */
   70     int bits;           /* number of bits (1-7) from byte at in - 1, or 0 */
   71     unsigned char window[WINSIZE];  /* preceding 32K of uncompressed data */
   72 };
   73 
   74 /* access point list */
   75 struct access {
   76     int have;           /* number of list entries filled in */
   77     int size;           /* number of list entries allocated */
   78     struct point *list; /* allocated list */
   79 };
   80 
   81 /* Deallocate an index built by build_index() */
   82 local void free_index(struct access *index)
   83 {
   84     if (index != NULL) {
   85         free(index->list);
   86         free(index);
   87     }
   88 }
   89 
   90 /* Add an entry to the access point list.  If out of memory, deallocate the
   91    existing list and return NULL. */
   92 local struct access *addpoint(struct access *index, int bits,
   93     off_t in, off_t out, unsigned left, unsigned char *window)
   94 {
   95     struct point *next;
   96 
   97     /* if list is empty, create it (start with eight points) */
   98     if (index == NULL) {
   99         index = malloc(sizeof(struct access));
  100         if (index == NULL) return NULL;
  101         index->list = malloc(sizeof(struct point) << 3);
  102         if (index->list == NULL) {
  103             free(index);
  104             return NULL;
  105         }
  106         index->size = 8;
  107         index->have = 0;
  108     }
  109 
  110     /* if list is full, make it bigger */
  111     else if (index->have == index->size) {
  112         index->size <<= 1;
  113         next = realloc(index->list, sizeof(struct point) * index->size);
  114         if (next == NULL) {
  115             free_index(index);
  116             return NULL;
  117         }
  118         index->list = next;
  119     }
  120 
  121     /* fill in entry and increment how many we have */
  122     next = index->list + index->have;
  123     next->bits = bits;
  124     next->in = in;
  125     next->out = out;
  126     if (left)
  127         memcpy(next->window, window + WINSIZE - left, left);
  128     if (left < WINSIZE)
  129         memcpy(next->window + left, window, WINSIZE - left);
  130     index->have++;
  131 
  132     /* return list, possibly reallocated */
  133     return index;
  134 }
  135 
  136 /* Make one entire pass through the compressed stream and build an index, with
  137    access points about every span bytes of uncompressed output -- span is
  138    chosen to balance the speed of random access against the memory requirements
  139    of the list, about 32K bytes per access point.  Note that data after the end
  140    of the first zlib or gzip stream in the file is ignored.  build_index()
  141    returns the number of access points on success (>= 1), Z_MEM_ERROR for out
  142    of memory, Z_DATA_ERROR for an error in the input file, or Z_ERRNO for a
  143    file read error.  On success, *built points to the resulting index. */
  144 local int build_index(FILE *in, off_t span, struct access **built)
  145 {
  146     int ret;
  147     off_t totin, totout;        /* our own total counters to avoid 4GB limit */
  148     off_t last;                 /* totout value of last access point */
  149     struct access *index;       /* access points being generated */
  150     z_stream strm;
  151     unsigned char input[CHUNK];
  152     unsigned char window[WINSIZE];
  153 
  154     /* initialize inflate */
  155     strm.zalloc = Z_NULL;
  156     strm.zfree = Z_NULL;
  157     strm.opaque = Z_NULL;
  158     strm.avail_in = 0;
  159     strm.next_in = Z_NULL;
  160     ret = inflateInit2(&strm, 47);      /* automatic zlib or gzip decoding */
  161     if (ret != Z_OK)
  162         return ret;
  163 
  164     /* inflate the input, maintain a sliding window, and build an index -- this
  165        also validates the integrity of the compressed data using the check
  166        information at the end of the gzip or zlib stream */
  167     totin = totout = last = 0;
  168     index = NULL;               /* will be allocated by first addpoint() */
  169     strm.avail_out = 0;
  170     do {
  171         /* get some compressed data from input file */
  172         strm.avail_in = fread(input, 1, CHUNK, in);
  173         if (ferror(in)) {
  174             ret = Z_ERRNO;
  175             goto build_index_error;
  176         }
  177         if (strm.avail_in == 0) {
  178             ret = Z_DATA_ERROR;
  179             goto build_index_error;
  180         }
  181         strm.next_in = input;
  182 
  183         /* process all of that, or until end of stream */
  184         do {
  185             /* reset sliding window if necessary */
  186             if (strm.avail_out == 0) {
  187                 strm.avail_out = WINSIZE;
  188                 strm.next_out = window;
  189             }
  190 
  191             /* inflate until out of input, output, or at end of block --
  192                update the total input and output counters */
  193             totin += strm.avail_in;
  194             totout += strm.avail_out;
  195             ret = inflate(&strm, Z_BLOCK);      /* return at end of block */
  196             totin -= strm.avail_in;
  197             totout -= strm.avail_out;
  198             if (ret == Z_NEED_DICT)
  199                 ret = Z_DATA_ERROR;
  200             if (ret == Z_MEM_ERROR || ret == Z_DATA_ERROR)
  201                 goto build_index_error;
  202             if (ret == Z_STREAM_END)
  203                 break;
  204 
  205             /* if at end of block, consider adding an index entry (note that if
  206                data_type indicates an end-of-block, then all of the
  207                uncompressed data from that block has been delivered, and none
  208                of the compressed data after that block has been consumed,
  209                except for up to seven bits) -- the totout == 0 provides an
  210                entry point after the zlib or gzip header, and assures that the
  211                index always has at least one access point; we avoid creating an
  212                access point after the last block by checking bit 6 of data_type
  213              */
  214             if ((strm.data_type & 128) && !(strm.data_type & 64) &&
  215                 (totout == 0 || totout - last > span)) {
  216                 index = addpoint(index, strm.data_type & 7, totin,
  217                                  totout, strm.avail_out, window);
  218                 if (index == NULL) {
  219                     ret = Z_MEM_ERROR;
  220                     goto build_index_error;
  221                 }
  222                 last = totout;
  223             }
  224         } while (strm.avail_in != 0);
  225     } while (ret != Z_STREAM_END);
  226 
  227     /* clean up and return index (release unused entries in list) */
  228     (void)inflateEnd(&strm);
  229     index->list = realloc(index->list, sizeof(struct point) * index->have);
  230     index->size = index->have;
  231     *built = index;
  232     return index->size;
  233 
  234     /* return error */
  235   build_index_error:
  236     (void)inflateEnd(&strm);
  237     if (index != NULL)
  238         free_index(index);
  239     return ret;
  240 }
  241 
  242 /* Use the index to read len bytes from offset into buf, return bytes read or
  243    negative for error (Z_DATA_ERROR or Z_MEM_ERROR).  If data is requested past
  244    the end of the uncompressed data, then extract() will return a value less
  245    than len, indicating how much as actually read into buf.  This function
  246    should not return a data error unless the file was modified since the index
  247    was generated.  extract() may also return Z_ERRNO if there is an error on
  248    reading or seeking the input file. */
  249 local int extract(FILE *in, struct access *index, off_t offset,
  250                   unsigned char *buf, int len)
  251 {
  252     int ret, skip;
  253     z_stream strm;
  254     struct point *here;
  255     unsigned char input[CHUNK];
  256     unsigned char discard[WINSIZE];
  257 
  258     /* proceed only if something reasonable to do */
  259     if (len < 0)
  260         return 0;
  261 
  262     /* find where in stream to start */
  263     here = index->list;
  264     ret = index->have;
  265     while (--ret && here[1].out <= offset)
  266         here++;
  267 
  268     /* initialize file and inflate state to start there */
  269     strm.zalloc = Z_NULL;
  270     strm.zfree = Z_NULL;
  271     strm.opaque = Z_NULL;
  272     strm.avail_in = 0;
  273     strm.next_in = Z_NULL;
  274     ret = inflateInit2(&strm, -15);         /* raw inflate */
  275     if (ret != Z_OK)
  276         return ret;
  277     ret = fseeko(in, here->in - (here->bits ? 1 : 0), SEEK_SET);
  278     if (ret == -1)
  279         goto extract_ret;
  280     if (here->bits) {
  281         ret = getc(in);
  282         if (ret == -1) {
  283             ret = ferror(in) ? Z_ERRNO : Z_DATA_ERROR;
  284             goto extract_ret;
  285         }
  286         (void)inflatePrime(&strm, here->bits, ret >> (8 - here->bits));
  287     }
  288     (void)inflateSetDictionary(&strm, here->window, WINSIZE);
  289 
  290     /* skip uncompressed bytes until offset reached, then satisfy request */
  291     offset -= here->out;
  292     strm.avail_in = 0;
  293     skip = 1;                               /* while skipping to offset */
  294     do {
  295         /* define where to put uncompressed data, and how much */
  296         if (offset == 0 && skip) {          /* at offset now */
  297             strm.avail_out = len;
  298             strm.next_out = buf;
  299             skip = 0;                       /* only do this once */
  300         }
  301         if (offset > WINSIZE) {             /* skip WINSIZE bytes */
  302             strm.avail_out = WINSIZE;
  303             strm.next_out = discard;
  304             offset -= WINSIZE;
  305         }
  306         else if (offset != 0) {             /* last skip */
  307             strm.avail_out = (unsigned)offset;
  308             strm.next_out = discard;
  309             offset = 0;
  310         }
  311 
  312         /* uncompress until avail_out filled, or end of stream */
  313         do {
  314             if (strm.avail_in == 0) {
  315                 strm.avail_in = fread(input, 1, CHUNK, in);
  316                 if (ferror(in)) {
  317                     ret = Z_ERRNO;
  318                     goto extract_ret;
  319                 }
  320                 if (strm.avail_in == 0) {
  321                     ret = Z_DATA_ERROR;
  322                     goto extract_ret;
  323                 }
  324                 strm.next_in = input;
  325             }
  326             ret = inflate(&strm, Z_NO_FLUSH);       /* normal inflate */
  327             if (ret == Z_NEED_DICT)
  328                 ret = Z_DATA_ERROR;
  329             if (ret == Z_MEM_ERROR || ret == Z_DATA_ERROR)
  330                 goto extract_ret;
  331             if (ret == Z_STREAM_END)
  332                 break;
  333         } while (strm.avail_out != 0);
  334 
  335         /* if reach end of stream, then don't keep trying to get more */
  336         if (ret == Z_STREAM_END)
  337             break;
  338 
  339         /* do until offset reached and requested data read, or stream ends */
  340     } while (skip);
  341 
  342     /* compute number of uncompressed bytes read after offset */
  343     ret = skip ? 0 : len - strm.avail_out;
  344 
  345     /* clean up and return bytes read or error */
  346   extract_ret:
  347     (void)inflateEnd(&strm);
  348     return ret;
  349 }
  350 
  351 /* Demonstrate the use of build_index() and extract() by processing the file
  352    provided on the command line, and the extracting 16K from about 2/3rds of
  353    the way through the uncompressed output, and writing that to stdout. */
  354 int main(int argc, char **argv)
  355 {
  356     int len;
  357     off_t offset;
  358     FILE *in;
  359     struct access *index = NULL;
  360     unsigned char buf[CHUNK];
  361 
  362     /* open input file */
  363     if (argc != 2) {
  364         fprintf(stderr, "usage: zran file.gz\n");
  365         return 1;
  366     }
  367     in = fopen(argv[1], "rb");
  368     if (in == NULL) {
  369         fprintf(stderr, "zran: could not open %s for reading\n", argv[1]);
  370         return 1;
  371     }
  372 
  373     /* build index */
  374     len = build_index(in, SPAN, &index);
  375     if (len < 0) {
  376         fclose(in);
  377         switch (len) {
  378         case Z_MEM_ERROR:
  379             fprintf(stderr, "zran: out of memory\n");
  380             break;
  381         case Z_DATA_ERROR:
  382             fprintf(stderr, "zran: compressed data error in %s\n", argv[1]);
  383             break;
  384         case Z_ERRNO:
  385             fprintf(stderr, "zran: read error on %s\n", argv[1]);
  386             break;
  387         default:
  388             fprintf(stderr, "zran: error %d while building index\n", len);
  389         }
  390         return 1;
  391     }
  392     fprintf(stderr, "zran: built index with %d access points\n", len);
  393 
  394     /* use index by reading some bytes from an arbitrary offset */
  395     offset = (index->list[index->have - 1].out << 1) / 3;
  396     len = extract(in, index, offset, buf, CHUNK);
  397     if (len < 0)
  398         fprintf(stderr, "zran: extraction failed: %s error\n",
  399                 len == Z_MEM_ERROR ? "out of memory" : "input corrupted");
  400     else {
  401         fwrite(buf, 1, len, stdout);
  402         fprintf(stderr, "zran: extracted %d bytes at %llu\n", len, offset);
  403     }
  404 
  405     /* clean up and exit */
  406     free_index(index);
  407     fclose(in);
  408     return 0;
  409 }