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