zlib-1.2.8/examples/zran.c

/* zran.c -- example of zlib/gzip stream indexing and random access
 * Copyright (C) 2005, 2012 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
   Version 1.1  29 Sep 2012  Mark Adler */

/* Version History:
 1.0  29 May 2005  First version
 1.1  29 Sep 2012  Fix memory reallocation error
 */

/* Illustrate the use of Z_BLOCK, inflatePrime(), and inflateSetDictionary()
   for random access of a compressed file.  A file containing a zlib or gzip
   stream is provided on the command line.  The compressed stream is decoded in
   its entirety, and an index built with access points about every SPAN bytes
   in the uncompressed output.  The compressed file is left open, and can then
   be read randomly, having to decompress on the average SPAN/2 uncompressed
   bytes before getting to the desired block of data.

   An access point can be created at the start of any deflate block, by saving
   the starting file offset and bit of that block, and the 32K bytes of
   uncompressed data that precede that block.  Also the uncompressed offset of
   that block is saved to provide a referece for locating a desired starting
   point in the uncompressed stream.  build_index() works by decompressing the
   input zlib or gzip stream a block at a time, and at the end of each block
   deciding if enough uncompressed data has gone by to justify the creation of
   a new access point.  If so, that point is saved in a data structure that
   grows as needed to accommodate the points.

   To use the index, an offset in the uncompressed data is provided, for which
   the latest accees point at or preceding that offset is located in the index.
   The input file is positioned to the specified location in the index, and if
   necessary the first few bits of the compressed data is read from the file.
   inflate is initialized with those bits and the 32K of uncompressed data, and
   the decompression then proceeds until the desired offset in the file is
   reached.  Then the decompression continues to read the desired uncompressed
   data from the file.

   Another approach would be to generate the index on demand.  In that case,
   requests for random access reads from the compressed data would try to use
   the index, but if a read far enough past the end of the index is required,
   then further index entries would be generated and added.

   There is some fair bit of overhead to starting inflation for the random
   access, mainly copying the 32K byte dictionary.  So if small pieces of the
   file are being accessed, it would make sense to implement a cache to hold
   some lookahead and avoid many calls to extract() for small lengths.

   Another way to build an index would be to use inflateCopy().  That would
   not be constrained to have access points at block boundaries, but requires
   more memory per access point, and also cannot be saved to file due to the
   use of pointers in the state.  The approach here allows for storage of the
   index in a file.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "zlib.h"

#define local static

#define SPAN 1048576L       /* desired distance between access points */
#define WINSIZE 32768U      /* sliding window size */
#define CHUNK 16384         /* file input buffer size */

/* access point entry */
struct point {
    off_t out;          /* corresponding offset in uncompressed data */
    off_t in;           /* offset in input file of first full byte */
    int bits;           /* number of bits (1-7) from byte at in - 1, or 0 */
    unsigned char window[WINSIZE];  /* preceding 32K of uncompressed data */
};

/* access point list */
struct access {
    int have;           /* number of list entries filled in */
    int size;           /* number of list entries allocated */
    struct point *list; /* allocated list */
};

/* Deallocate an index built by build_index() */
local void free_index(struct access *index)
{
    if (index != NULL) {
        free(index->list);
        free(index);
    }
}

/* Add an entry to the access point list.  If out of memory, deallocate the
   existing list and return NULL. */
local struct access *addpoint(struct access *index, int bits,
    off_t in, off_t out, unsigned left, unsigned char *window)
{
    struct point *next;

    /* if list is empty, create it (start with eight points) */
    if (index == NULL) {
        index = malloc(sizeof(struct access));
        if (index == NULL) return NULL;
        index->list = malloc(sizeof(struct point) << 3);
        if (index->list == NULL) {
            free(index);
            return NULL;
        }
        index->size = 8;
        index->have = 0;
    }

    /* if list is full, make it bigger */
    else if (index->have == index->size) {
        index->size <<= 1;
        next = realloc(index->list, sizeof(struct point) * index->size);
        if (next == NULL) {
            free_index(index);
            return NULL;
        }
        index->list = next;
    }

    /* fill in entry and increment how many we have */
    next = index->list + index->have;
    next->bits = bits;
    next->in = in;
    next->out = out;
    if (left)
        memcpy(next->window, window + WINSIZE - left, left);
    if (left < WINSIZE)
        memcpy(next->window + left, window, WINSIZE - left);
    index->have++;

    /* return list, possibly reallocated */
    return index;
}

/* Make one entire pass through the compressed stream and build an index, with
   access points about every span bytes of uncompressed output -- span is
   chosen to balance the speed of random access against the memory requirements
   of the list, about 32K bytes per access point.  Note that data after the end
   of the first zlib or gzip stream in the file is ignored.  build_index()
   returns the number of access points on success (>= 1), Z_MEM_ERROR for out
   of memory, Z_DATA_ERROR for an error in the input file, or Z_ERRNO for a
   file read error.  On success, *built points to the resulting index. */
local int build_index(FILE *in, off_t span, struct access **built)
{
    int ret;
    off_t totin, totout;        /* our own total counters to avoid 4GB limit */
    off_t last;                 /* totout value of last access point */
    struct access *index;       /* access points being generated */
    z_stream strm;
    unsigned char input[CHUNK];
    unsigned char window[WINSIZE];

    /* initialize inflate */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = 0;
    strm.next_in = Z_NULL;
    ret = inflateInit2(&strm, 47);      /* automatic zlib or gzip decoding */
    if (ret != Z_OK)
        return ret;

    /* inflate the input, maintain a sliding window, and build an index -- this
       also validates the integrity of the compressed data using the check
       information at the end of the gzip or zlib stream */
    totin = totout = last = 0;
    index = NULL;               /* will be allocated by first addpoint() */
    strm.avail_out = 0;
    do {
        /* get some compressed data from input file */
        strm.avail_in = fread(input, 1, CHUNK, in);
        if (ferror(in)) {
            ret = Z_ERRNO;
            goto build_index_error;
        }
        if (strm.avail_in == 0) {
            ret = Z_DATA_ERROR;
            goto build_index_error;
        }
        strm.next_in = input;

        /* process all of that, or until end of stream */
        do {
            /* reset sliding window if necessary */
            if (strm.avail_out == 0) {
                strm.avail_out = WINSIZE;
                strm.next_out = window;
            }

            /* inflate until out of input, output, or at end of block --
               update the total input and output counters */
            totin += strm.avail_in;
            totout += strm.avail_out;
            ret = inflate(&strm, Z_BLOCK);      /* return at end of block */
            totin -= strm.avail_in;
            totout -= strm.avail_out;
            if (ret == Z_NEED_DICT)
                ret = Z_DATA_ERROR;
            if (ret == Z_MEM_ERROR || ret == Z_DATA_ERROR)
                goto build_index_error;
            if (ret == Z_STREAM_END)
                break;

            /* if at end of block, consider adding an index entry (note that if
               data_type indicates an end-of-block, then all of the
               uncompressed data from that block has been delivered, and none
               of the compressed data after that block has been consumed,
               except for up to seven bits) -- the totout == 0 provides an
               entry point after the zlib or gzip header, and assures that the
               index always has at least one access point; we avoid creating an
               access point after the last block by checking bit 6 of data_type
             */
            if ((strm.data_type & 128) && !(strm.data_type & 64) &&
                (totout == 0 || totout - last > span)) {
                index = addpoint(index, strm.data_type & 7, totin,
                                 totout, strm.avail_out, window);
                if (index == NULL) {
                    ret = Z_MEM_ERROR;
                    goto build_index_error;
                }
                last = totout;
            }
        } while (strm.avail_in != 0);
    } while (ret != Z_STREAM_END);

    /* clean up and return index (release unused entries in list) */
    (void)inflateEnd(&strm);
    index->list = realloc(index->list, sizeof(struct point) * index->have);
    index->size = index->have;
    *built = index;
    return index->size;

    /* return error */
  build_index_error:
    (void)inflateEnd(&strm);
    if (index != NULL)
        free_index(index);
    return ret;
}

/* Use the index to read len bytes from offset into buf, return bytes read or
   negative for error (Z_DATA_ERROR or Z_MEM_ERROR).  If data is requested past
   the end of the uncompressed data, then extract() will return a value less
   than len, indicating how much as actually read into buf.  This function
   should not return a data error unless the file was modified since the index
   was generated.  extract() may also return Z_ERRNO if there is an error on
   reading or seeking the input file. */
local int extract(FILE *in, struct access *index, off_t offset,
                  unsigned char *buf, int len)
{
    int ret, skip;
    z_stream strm;
    struct point *here;
    unsigned char input[CHUNK];
    unsigned char discard[WINSIZE];

    /* proceed only if something reasonable to do */
    if (len < 0)
        return 0;

    /* find where in stream to start */
    here = index->list;
    ret = index->have;
    while (--ret && here[1].out <= offset)
        here++;

    /* initialize file and inflate state to start there */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = 0;
    strm.next_in = Z_NULL;
    ret = inflateInit2(&strm, -15);         /* raw inflate */
    if (ret != Z_OK)
        return ret;
    ret = fseeko(in, here->in - (here->bits ? 1 : 0), SEEK_SET);
    if (ret == -1)
        goto extract_ret;
    if (here->bits) {
        ret = getc(in);
        if (ret == -1) {
            ret = ferror(in) ? Z_ERRNO : Z_DATA_ERROR;
            goto extract_ret;
        }
        (void)inflatePrime(&strm, here->bits, ret >> (8 - here->bits));
    }
    (void)inflateSetDictionary(&strm, here->window, WINSIZE);

    /* skip uncompressed bytes until offset reached, then satisfy request */
    offset -= here->out;
    strm.avail_in = 0;
    skip = 1;                               /* while skipping to offset */
    do {
        /* define where to put uncompressed data, and how much */
        if (offset == 0 && skip) {          /* at offset now */
            strm.avail_out = len;
            strm.next_out = buf;
            skip = 0;                       /* only do this once */
        }
        if (offset > WINSIZE) {             /* skip WINSIZE bytes */
            strm.avail_out = WINSIZE;
            strm.next_out = discard;
            offset -= WINSIZE;
        }
        else if (offset != 0) {             /* last skip */
            strm.avail_out = (unsigned)offset;
            strm.next_out = discard;
            offset = 0;
        }

        /* uncompress until avail_out filled, or end of stream */
        do {
            if (strm.avail_in == 0) {
                strm.avail_in = fread(input, 1, CHUNK, in);
                if (ferror(in)) {
                    ret = Z_ERRNO;
                    goto extract_ret;
                }
                if (strm.avail_in == 0) {
                    ret = Z_DATA_ERROR;
                    goto extract_ret;
                }
                strm.next_in = input;
            }
            ret = inflate(&strm, Z_NO_FLUSH);       /* normal inflate */
            if (ret == Z_NEED_DICT)
                ret = Z_DATA_ERROR;
            if (ret == Z_MEM_ERROR || ret == Z_DATA_ERROR)
                goto extract_ret;
            if (ret == Z_STREAM_END)
                break;
        } while (strm.avail_out != 0);

        /* if reach end of stream, then don't keep trying to get more */
        if (ret == Z_STREAM_END)
            break;

        /* do until offset reached and requested data read, or stream ends */
    } while (skip);

    /* compute number of uncompressed bytes read after offset */
    ret = skip ? 0 : len - strm.avail_out;

    /* clean up and return bytes read or error */
  extract_ret:
    (void)inflateEnd(&strm);
    return ret;
}

/* Demonstrate the use of build_index() and extract() by processing the file
   provided on the command line, and the extracting 16K from about 2/3rds of
   the way through the uncompressed output, and writing that to stdout. */
int main(int argc, char **argv)
{
    int len;
    off_t offset;
    FILE *in;
    struct access *index = NULL;
    unsigned char buf[CHUNK];

    /* open input file */
    if (argc != 2) {
        fprintf(stderr, "usage: zran file.gz\n");
        return 1;
    }
    in = fopen(argv[1], "rb");
    if (in == NULL) {
        fprintf(stderr, "zran: could not open %s for reading\n", argv[1]);
        return 1;
    }

    /* build index */
    len = build_index(in, SPAN, &index);
    if (len < 0) {
        fclose(in);
        switch (len) {
        case Z_MEM_ERROR:
            fprintf(stderr, "zran: out of memory\n");
            break;
        case Z_DATA_ERROR:
            fprintf(stderr, "zran: compressed data error in %s\n", argv[1]);
            break;
        case Z_ERRNO:
            fprintf(stderr, "zran: read error on %s\n", argv[1]);
            break;
        default:
            fprintf(stderr, "zran: error %d while building index\n", len);
        }
        return 1;
    }
    fprintf(stderr, "zran: built index with %d access points\n", len);

    /* use index by reading some bytes from an arbitrary offset */
    offset = (index->list[index->have - 1].out << 1) / 3;
    len = extract(in, index, offset, buf, CHUNK);
    if (len < 0)
        fprintf(stderr, "zran: extraction failed: %s error\n",
                len == Z_MEM_ERROR ? "out of memory" : "input corrupted");
    else {
        fwrite(buf, 1, len, stdout);
        fprintf(stderr, "zran: extracted %d bytes at %llu\n", len, offset);
    }

    /* clean up and exit */
    free_index(index);
    fclose(in);
    return 0;
}
Revision:	1096
Committed:	Sat Dec 30 14:40:33 2017 UTC (7 years, 9 months ago) by s10k
Content type:	text/x-csrc
File size:	15438 byte(s)
Log Message:	Added zlib, quazip, basicxmlsyntaxhighlighter, conditionalsemaphore and linenumberdisplay libraries. zlib and quazip are pre-compiled, but you can compile them yourself, just delete the dll files (or equivalent binary files to your OS)
#	Content
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 accees 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	}