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
12 local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
13 local int gz_avail OF((gz_statep));
14 local int gz_look OF((gz_statep));
15 local int gz_decomp OF((gz_statep));
16 local int gz_fetch OF((gz_statep));
17 local int gz_skip OF((gz_statep, z_off64_t));
18 local z_size_t gz_read OF((gz_statep, voidp, z_size_t));
20 /* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
21 state->fd, and update state->eof, state->err, and state->msg as appropriate.
22 This function needs to loop on read(), since read() is not guaranteed to
23 read the number of bytes requested, depending on the type of descriptor. */
24 local int gz_load(state, buf, len, have)
31 unsigned get, max = ((unsigned)-1 >> 2) + 1;
38 ret = read(state->fd, buf + *have, get);
41 *have += (unsigned)ret;
42 } while (*have < len);
44 gz_error(state, Z_ERRNO, zstrerror());
52 /* Load up input buffer and set eof flag if last data loaded -- return -1 on
53 error, 0 otherwise. Note that the eof flag is set when the end of the input
54 file is reached, even though there may be unused data in the buffer. Once
55 that data has been used, no more attempts will be made to read the file.
56 If strm->avail_in != 0, then the current data is moved to the beginning of
57 the input buffer, and then the remainder of the buffer is loaded with the
58 available data from the input file. */
59 local int gz_avail(state)
63 z_streamp strm = &(state->strm);
65 if (state->err != Z_OK && state->err != Z_BUF_ERROR)
67 if (state->eof == 0) {
68 if (strm->avail_in) { /* copy what's there to the start */
69 unsigned char *p = state->in;
70 unsigned const char *q = strm->next_in;
71 unsigned n = strm->avail_in;
76 if (gz_load(state, state->in + strm->avail_in,
77 state->size - strm->avail_in, &got) == -1)
79 strm->avail_in += got;
80 strm->next_in = state->in;
85 /* Look for gzip header, set up for inflate or copy. state->x.have must be 0.
86 If this is the first time in, allocate required memory. state->how will be
87 left unchanged if there is no more input data available, will be set to COPY
88 if there is no gzip header and direct copying will be performed, or it will
89 be set to GZIP for decompression. If direct copying, then leftover input
90 data from the input buffer will be copied to the output buffer. In that
91 case, all further file reads will be directly to either the output buffer or
92 a user buffer. If decompressing, the inflate state will be initialized.
93 gz_look() will return 0 on success or -1 on failure. */
94 local int gz_look(state)
97 z_streamp strm = &(state->strm);
99 /* allocate read buffers and inflate memory */
100 if (state->size == 0) {
101 /* allocate buffers */
102 state->in = (unsigned char *)malloc(state->want);
103 state->out = (unsigned char *)malloc(state->want << 1);
104 if (state->in == NULL || state->out == NULL) {
107 gz_error(state, Z_MEM_ERROR, "out of memory");
110 state->size = state->want;
112 /* allocate inflate memory */
113 state->strm.zalloc = Z_NULL;
114 state->strm.zfree = Z_NULL;
115 state->strm.opaque = Z_NULL;
116 state->strm.avail_in = 0;
117 state->strm.next_in = Z_NULL;
118 if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) { /* gunzip */
122 gz_error(state, Z_MEM_ERROR, "out of memory");
127 /* get at least the magic bytes in the input buffer */
128 if (strm->avail_in < 2) {
129 if (gz_avail(state) == -1)
131 if (strm->avail_in == 0)
135 /* look for gzip magic bytes -- if there, do gzip decoding (note: there is
136 a logical dilemma here when considering the case of a partially written
137 gzip file, to wit, if a single 31 byte is written, then we cannot tell
138 whether this is a single-byte file, or just a partially written gzip
139 file -- for here we assume that if a gzip file is being written, then
140 the header will be written in a single operation, so that reading a
141 single byte is sufficient indication that it is not a gzip file) */
142 if (strm->avail_in > 1 &&
143 strm->next_in[0] == 31 && strm->next_in[1] == 139) {
150 /* no gzip header -- if we were decoding gzip before, then this is trailing
151 garbage. Ignore the trailing garbage and finish. */
152 if (state->direct == 0) {
159 /* doing raw i/o, copy any leftover input to output -- this assumes that
160 the output buffer is larger than the input buffer, which also assures
161 space for gzungetc() */
162 state->x.next = state->out;
163 if (strm->avail_in) {
164 memcpy(state->x.next, strm->next_in, strm->avail_in);
165 state->x.have = strm->avail_in;
173 /* Decompress from input to the provided next_out and avail_out in the state.
174 On return, state->x.have and state->x.next point to the just decompressed
175 data. If the gzip stream completes, state->how is reset to LOOK to look for
176 the next gzip stream or raw data, once state->x.have is depleted. Returns 0
177 on success, -1 on failure. */
178 local int gz_decomp(state)
183 z_streamp strm = &(state->strm);
185 /* fill output buffer up to end of deflate stream */
186 had = strm->avail_out;
188 /* get more input for inflate() */
189 if (strm->avail_in == 0 && gz_avail(state) == -1)
191 if (strm->avail_in == 0) {
192 gz_error(state, Z_BUF_ERROR, "unexpected end of file");
196 /* decompress and handle errors */
197 ret = inflate(strm, Z_NO_FLUSH);
198 if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
199 gz_error(state, Z_STREAM_ERROR,
200 "internal error: inflate stream corrupt");
203 if (ret == Z_MEM_ERROR) {
204 gz_error(state, Z_MEM_ERROR, "out of memory");
207 if (ret == Z_DATA_ERROR) { /* deflate stream invalid */
208 gz_error(state, Z_DATA_ERROR,
209 strm->msg == NULL ? "compressed data error" : strm->msg);
212 } while (strm->avail_out && ret != Z_STREAM_END);
214 /* update available output */
215 state->x.have = had - strm->avail_out;
216 state->x.next = strm->next_out - state->x.have;
218 /* if the gzip stream completed successfully, look for another */
219 if (ret == Z_STREAM_END)
222 /* good decompression */
226 /* Fetch data and put it in the output buffer. Assumes state->x.have is 0.
227 Data is either copied from the input file or decompressed from the input
228 file depending on state->how. If state->how is LOOK, then a gzip header is
229 looked for to determine whether to copy or decompress. Returns -1 on error,
230 otherwise 0. gz_fetch() will leave state->how as COPY or GZIP unless the
231 end of the input file has been reached and all data has been processed. */
232 local int gz_fetch(state)
235 z_streamp strm = &(state->strm);
239 case LOOK: /* -> LOOK, COPY (only if never GZIP), or GZIP */
240 if (gz_look(state) == -1)
242 if (state->how == LOOK)
245 case COPY: /* -> COPY */
246 if (gz_load(state, state->out, state->size << 1, &(state->x.have))
249 state->x.next = state->out;
251 case GZIP: /* -> GZIP or LOOK (if end of gzip stream) */
252 strm->avail_out = state->size << 1;
253 strm->next_out = state->out;
254 if (gz_decomp(state) == -1)
257 } while (state->x.have == 0 && (!state->eof || strm->avail_in));
261 /* Skip len uncompressed bytes of output. Return -1 on error, 0 on success. */
262 local int gz_skip(state, len)
268 /* skip over len bytes or reach end-of-file, whichever comes first */
270 /* skip over whatever is in output buffer */
272 n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
273 (unsigned)len : state->x.have;
280 /* output buffer empty -- return if we're at the end of the input */
281 else if (state->eof && state->strm.avail_in == 0)
284 /* need more data to skip -- load up output buffer */
286 /* get more output, looking for header if required */
287 if (gz_fetch(state) == -1)
293 /* Read len bytes into buf from file, or less than len up to the end of the
294 input. Return the number of bytes read. If zero is returned, either the
295 end of file was reached, or there was an error. state->err must be
296 consulted in that case to determine which. */
297 local z_size_t gz_read(state, buf, len)
305 /* if len is zero, avoid unnecessary operations */
309 /* process a skip request */
312 if (gz_skip(state, state->skip) == -1)
316 /* get len bytes to buf, or less than len if at the end */
319 /* set n to the maximum amount of len that fits in an unsigned int */
324 /* first just try copying data from the output buffer */
326 if (state->x.have < n)
328 memcpy(buf, state->x.next, n);
333 /* output buffer empty -- return if we're at the end of the input */
334 else if (state->eof && state->strm.avail_in == 0) {
335 state->past = 1; /* tried to read past end */
339 /* need output data -- for small len or new stream load up our output
341 else if (state->how == LOOK || n < (state->size << 1)) {
342 /* get more output, looking for header if required */
343 if (gz_fetch(state) == -1)
345 continue; /* no progress yet -- go back to copy above */
346 /* the copy above assures that we will leave with space in the
347 output buffer, allowing at least one gzungetc() to succeed */
350 /* large len -- read directly into user buffer */
351 else if (state->how == COPY) { /* read directly */
352 if (gz_load(state, (unsigned char *)buf, n, &n) == -1)
356 /* large len -- decompress directly into user buffer */
357 else { /* state->how == GZIP */
358 state->strm.avail_out = n;
359 state->strm.next_out = (unsigned char *)buf;
360 if (gz_decomp(state) == -1)
366 /* update progress */
368 buf = (char *)buf + n;
373 /* return number of bytes read into user buffer */
377 /* -- see zlib.h -- */
378 int ZEXPORT gzread(file, buf, len)
385 /* get internal structure */
388 state = (gz_statep)file;
390 /* check that we're reading and that there's no (serious) error */
391 if (state->mode != GZ_READ ||
392 (state->err != Z_OK && state->err != Z_BUF_ERROR))
395 /* since an int is returned, make sure len fits in one, otherwise return
396 with an error (this avoids a flaw in the interface) */
398 gz_error(state, Z_STREAM_ERROR, "request does not fit in an int");
402 /* read len or fewer bytes to buf */
403 len = gz_read(state, buf, len);
405 /* check for an error */
406 if (len == 0 && state->err != Z_OK && state->err != Z_BUF_ERROR)
409 /* return the number of bytes read (this is assured to fit in an int) */
413 /* -- see zlib.h -- */
414 z_size_t ZEXPORT gzfread(buf, size, nitems, file)
423 /* get internal structure */
426 state = (gz_statep)file;
428 /* check that we're reading and that there's no (serious) error */
429 if (state->mode != GZ_READ ||
430 (state->err != Z_OK && state->err != Z_BUF_ERROR))
433 /* compute bytes to read -- error on overflow */
435 if (size && len / size != nitems) {
436 gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
440 /* read len or fewer bytes to buf, return the number of full items read */
441 return len ? gz_read(state, buf, len) / size : 0;
444 /* -- see zlib.h -- */
450 int ZEXPORT gzgetc(file)
454 unsigned char buf[1];
457 /* get internal structure */
460 state = (gz_statep)file;
462 /* check that we're reading and that there's no (serious) error */
463 if (state->mode != GZ_READ ||
464 (state->err != Z_OK && state->err != Z_BUF_ERROR))
467 /* try output buffer (no need to check for skip request) */
471 return *(state->x.next)++;
474 /* nothing there -- try gz_read() */
475 ret = gz_read(state, buf, 1);
476 return ret < 1 ? -1 : buf[0];
479 int ZEXPORT gzgetc_(file)
485 /* -- see zlib.h -- */
486 int ZEXPORT gzungetc(c, file)
492 /* get internal structure */
495 state = (gz_statep)file;
497 /* check that we're reading and that there's no (serious) error */
498 if (state->mode != GZ_READ ||
499 (state->err != Z_OK && state->err != Z_BUF_ERROR))
502 /* process a skip request */
505 if (gz_skip(state, state->skip) == -1)
513 /* if output buffer empty, put byte at end (allows more pushing) */
514 if (state->x.have == 0) {
516 state->x.next = state->out + (state->size << 1) - 1;
517 state->x.next[0] = (unsigned char)c;
523 /* if no room, give up (must have already done a gzungetc()) */
524 if (state->x.have == (state->size << 1)) {
525 gz_error(state, Z_DATA_ERROR, "out of room to push characters");
529 /* slide output data if needed and insert byte before existing data */
530 if (state->x.next == state->out) {
531 unsigned char *src = state->out + state->x.have;
532 unsigned char *dest = state->out + (state->size << 1);
533 while (src > state->out)
535 state->x.next = dest;
539 state->x.next[0] = (unsigned char)c;
545 /* -- see zlib.h -- */
546 char * ZEXPORT gzgets(file, buf, len)
556 /* check parameters and get internal structure */
557 if (file == NULL || buf == NULL || len < 1)
559 state = (gz_statep)file;
561 /* check that we're reading and that there's no (serious) error */
562 if (state->mode != GZ_READ ||
563 (state->err != Z_OK && state->err != Z_BUF_ERROR))
566 /* process a skip request */
569 if (gz_skip(state, state->skip) == -1)
573 /* copy output bytes up to new line or len - 1, whichever comes first --
574 append a terminating zero to the string (we don't check for a zero in
575 the contents, let the user worry about that) */
577 left = (unsigned)len - 1;
579 /* assure that something is in the output buffer */
580 if (state->x.have == 0 && gz_fetch(state) == -1)
581 return NULL; /* error */
582 if (state->x.have == 0) { /* end of file */
583 state->past = 1; /* read past end */
584 break; /* return what we have */
587 /* look for end-of-line in current output buffer */
588 n = state->x.have > left ? left : state->x.have;
589 eol = (unsigned char *)memchr(state->x.next, '\n', n);
591 n = (unsigned)(eol - state->x.next) + 1;
593 /* copy through end-of-line, or remainder if not found */
594 memcpy(buf, state->x.next, n);
600 } while (left && eol == NULL);
602 /* return terminated string, or if nothing, end of file */
609 /* -- see zlib.h -- */
610 int ZEXPORT gzdirect(file)
615 /* get internal structure */
618 state = (gz_statep)file;
620 /* if the state is not known, but we can find out, then do so (this is
621 mainly for right after a gzopen() or gzdopen()) */
622 if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
623 (void)gz_look(state);
625 /* return 1 if transparent, 0 if processing a gzip stream */
626 return state->direct;
629 /* -- see zlib.h -- */
630 int ZEXPORT gzclose_r(file)
636 /* get internal structure */
638 return Z_STREAM_ERROR;
639 state = (gz_statep)file;
641 /* check that we're reading */
642 if (state->mode != GZ_READ)
643 return Z_STREAM_ERROR;
645 /* free memory and close file */
647 inflateEnd(&(state->strm));
651 err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
652 gz_error(state, Z_OK, NULL);
654 ret = close(state->fd);
656 return ret ? Z_ERRNO : err;