gcc/
[official-gcc.git] / zlib / gzread.c
blobbf4538eb274245ad118edd3eaac38ee9e697c2b5
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 */
6 #include "gzguts.h"
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));
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;
26 int ret;
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;
39 if (ret == 0)
40 state->eof = 1;
41 return 0;
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;
54 unsigned got;
55 z_streamp strm = &(state->strm);
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);
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;
74 return 0;
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;
89 z_streamp strm = &(state->strm);
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;
104 state->size = state->want;
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;
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;
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;
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;
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;
162 state->how = COPY;
163 state->direct = 1;
164 return 0;
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;
175 int ret = Z_OK;
176 unsigned had;
177 z_streamp strm = &(state->strm);
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;
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;
197 if (ret == Z_MEM_ERROR) {
198 gz_error(state, Z_MEM_ERROR, "out of memory");
199 return -1;
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;
206 } while (strm->avail_out && ret != Z_STREAM_END);
208 /* update available output */
209 state->x.have = had - strm->avail_out;
210 state->x.next = strm->next_out - state->x.have;
212 /* if the gzip stream completed successfully, look for another */
213 if (ret == Z_STREAM_END)
214 state->how = LOOK;
216 /* good decompression */
217 return 0;
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;
229 z_streamp strm = &(state->strm);
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;
251 } while (state->x.have == 0 && (!state->eof || strm->avail_in));
252 return 0;
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;
260 unsigned n;
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;
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;
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;
284 return 0;
287 /* -- see zlib.h -- */
288 int ZEXPORT gzread(file, buf, len)
289 gzFile file;
290 voidp buf;
291 unsigned len;
293 unsigned got, n;
294 gz_statep state;
295 z_streamp strm;
297 /* get internal structure */
298 if (file == NULL)
299 return -1;
300 state = (gz_statep)file;
301 strm = &(state->strm);
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;
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;
315 /* if len is zero, avoid unnecessary operations */
316 if (len == 0)
317 return 0;
319 /* process a skip request */
320 if (state->seek) {
321 state->seek = 0;
322 if (gz_skip(state, state->skip) == -1)
323 return -1;
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;
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;
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 */
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;
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;
370 /* update progress */
371 len -= n;
372 buf = (char *)buf + n;
373 got += n;
374 state->x.pos += n;
375 } while (len);
377 /* return number of bytes read into user buffer (will fit in int) */
378 return (int)got;
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;
390 int ret;
391 unsigned char buf[1];
392 gz_statep state;
394 /* get internal structure */
395 if (file == NULL)
396 return -1;
397 state = (gz_statep)file;
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;
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)++;
411 /* nothing there -- try gzread() */
412 ret = gzread(file, buf, 1);
413 return ret < 1 ? -1 : buf[0];
416 int ZEXPORT gzgetc_(file)
417 gzFile file;
419 return gzgetc(file);
422 /* -- see zlib.h -- */
423 int ZEXPORT gzungetc(c, file)
424 int c;
425 gzFile file;
427 gz_statep state;
429 /* get internal structure */
430 if (file == NULL)
431 return -1;
432 state = (gz_statep)file;
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;
439 /* process a skip request */
440 if (state->seek) {
441 state->seek = 0;
442 if (gz_skip(state, state->skip) == -1)
443 return -1;
446 /* can't push EOF */
447 if (c < 0)
448 return -1;
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;
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;
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;
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;
482 /* -- see zlib.h -- */
483 char * ZEXPORT gzgets(file, buf, len)
484 gzFile file;
485 char *buf;
486 int len;
488 unsigned left, n;
489 char *str;
490 unsigned char *eol;
491 gz_statep state;
493 /* check parameters and get internal structure */
494 if (file == NULL || buf == NULL || len < 1)
495 return NULL;
496 state = (gz_statep)file;
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;
503 /* process a skip request */
504 if (state->seek) {
505 state->seek = 0;
506 if (gz_skip(state, state->skip) == -1)
507 return NULL;
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 */
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;
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);
539 /* return terminated string, or if nothing, end of file */
540 if (buf == str)
541 return NULL;
542 buf[0] = 0;
543 return str;
546 /* -- see zlib.h -- */
547 int ZEXPORT gzdirect(file)
548 gzFile file;
550 gz_statep state;
552 /* get internal structure */
553 if (file == NULL)
554 return 0;
555 state = (gz_statep)file;
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);
562 /* return 1 if transparent, 0 if processing a gzip stream */
563 return state->direct;
566 /* -- see zlib.h -- */
567 int ZEXPORT gzclose_r(file)
568 gzFile file;
570 int ret, err;
571 gz_statep state;
573 /* get internal structure */
574 if (file == NULL)
575 return Z_STREAM_ERROR;
576 state = (gz_statep)file;
578 /* check that we're reading */
579 if (state->mode != GZ_READ)
580 return Z_STREAM_ERROR;
582 /* free memory and close file */
583 if (state->size) {
584 inflateEnd(&(state->strm));
585 free(state->out);
586 free(state->in);
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;