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