1 /* $NetBSD: gzio.c,v 1.4 2013/11/07 17:26:13 christos Exp $ */
2
3 /* gzio.c -- IO on .gz files
4 * Copyright (C) 1995-2005 Jean-loup Gailly.
5 * For conditions of distribution and use, see copyright notice in zlib.h
6 *
7 * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.
8 */
9
10 /* @(#) Id */
11
12 #include <stdio.h>
13
14 #include "zutil.h"
15
16 #ifdef NO_DEFLATE /* for compatibility with old definition */
17 # define NO_GZCOMPRESS
18 #endif
19
20 #ifndef NO_DUMMY_DECL
21 struct internal_state {int dummy;}; /* for buggy compilers */
22 #endif
23
24 #ifndef Z_BUFSIZE
25 # ifdef MAXSEG_64K
26 # define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
27 # else
28 # define Z_BUFSIZE 16384
29 # endif
30 #endif
31 #ifndef Z_PRINTF_BUFSIZE
32 # define Z_PRINTF_BUFSIZE 4096
33 #endif
34
35 #ifdef __MVS__
36 # pragma map (fdopen , "\174\174FDOPEN")
37 FILE *fdopen(int, const char *);
38 #endif
39
40 #ifndef STDC
41 extern voidp malloc OF((uInt size));
42 extern void free OF((voidpf ptr));
43 #endif
44
45 #define ALLOC(size) malloc(size)
46 #define TRYFREE(p) {if (p) free(p);}
47
48 static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
49
50 /* gzip flag byte */
51 #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
52 #define HEAD_CRC 0x02 /* bit 1 set: header CRC present */
53 #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
54 #define ORIG_NAME 0x08 /* bit 3 set: original file name present */
55 #define COMMENT 0x10 /* bit 4 set: file comment present */
56 #define RESERVED 0xE0 /* bits 5..7: reserved */
57
58 typedef struct gz_stream {
59 z_stream stream;
60 int z_err; /* error code for last stream operation */
61 int z_eof; /* set if end of input file */
62 FILE *file; /* .gz file */
63 Byte *inbuf; /* input buffer */
64 Byte *outbuf; /* output buffer */
65 uLong crc; /* crc32 of uncompressed data */
66 char *msg; /* error message */
67 char *path; /* path name for debugging only */
68 int transparent; /* 1 if input file is not a .gz file */
69 char mode; /* 'w' or 'r' */
70 z_off_t start; /* start of compressed data in file (header skipped) */
71 z_off_t in; /* bytes into deflate or inflate */
72 z_off_t out; /* bytes out of deflate or inflate */
73 int back; /* one character push-back */
74 int last; /* true if push-back is last character */
75 } gz_stream;
76
77
78 local gzFile gz_open OF((const char *path, const char *mode, int fd));
79 #ifndef NO_GZCOMPRESS
80 local int do_flush OF((gzFile file, int flush));
81 #endif
82 local int get_byte OF((gz_stream *s));
83 local void check_header OF((gz_stream *s));
84 local int destroy OF((gz_stream *s));
85 #ifndef NO_GZCOMPRESS
86 local void putLong OF((FILE *file, uLong x));
87 #endif
88 local uLong getLong OF((gz_stream *s));
89
90 /* ===========================================================================
91 Opens a gzip (.gz) file for reading or writing. The mode parameter
92 is as in fopen ("rb" or "wb"). The file is given either by file descriptor
93 or path name (if fd == -1).
94 gz_open returns NULL if the file could not be opened or if there was
95 insufficient memory to allocate the (de)compression state; errno
96 can be checked to distinguish the two cases (if errno is zero, the
97 zlib error is Z_MEM_ERROR).
98 */
gz_open(path,mode,fd)99 local gzFile gz_open (path, mode, fd)
100 const char *path;
101 const char *mode;
102 int fd;
103 {
104 int err;
105 int level = Z_DEFAULT_COMPRESSION; /* compression level */
106 int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
107 const char *p = mode;
108 gz_stream *s;
109 char fmode[80]; /* copy of mode, without the compression level */
110 char *m = fmode;
111
112 if (!path || !mode) return Z_NULL;
113
114 s = (gz_stream *)ALLOC(sizeof(gz_stream));
115 if (!s) return Z_NULL;
116
117 s->stream.zalloc = (alloc_func)0;
118 s->stream.zfree = (free_func)0;
119 s->stream.opaque = (voidpf)0;
120 s->stream.next_in = s->inbuf = Z_NULL;
121 s->stream.next_out = s->outbuf = Z_NULL;
122 s->stream.avail_in = s->stream.avail_out = 0;
123 s->file = NULL;
124 s->z_err = Z_OK;
125 s->z_eof = 0;
126 s->in = 0;
127 s->out = 0;
128 s->back = EOF;
129 s->crc = crc32(0L, Z_NULL, 0);
130 s->msg = NULL;
131 s->transparent = 0;
132
133 s->path = (char*)ALLOC(strlen(path)+1);
134 if (s->path == NULL) {
135 return destroy(s), (gzFile)Z_NULL;
136 }
137 strcpy(s->path, path); /* do this early for debugging */
138
139 s->mode = '\0';
140 do {
141 if (*p == 'r') s->mode = 'r';
142 if (*p == 'w' || *p == 'a') s->mode = 'w';
143 if (*p >= '0' && *p <= '9') {
144 level = *p - '0';
145 } else if (*p == 'f') {
146 strategy = Z_FILTERED;
147 } else if (*p == 'h') {
148 strategy = Z_HUFFMAN_ONLY;
149 } else if (*p == 'R') {
150 strategy = Z_RLE;
151 } else {
152 *m++ = *p; /* copy the mode */
153 }
154 } while (*p++ && m != fmode + sizeof(fmode));
155 if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
156
157 if (s->mode == 'w') {
158 #ifdef NO_GZCOMPRESS
159 err = Z_STREAM_ERROR;
160 __USE(level);
161 __USE(strategy);
162 #else
163 err = deflateInit2(&(s->stream), level,
164 Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
165 /* windowBits is passed < 0 to suppress zlib header */
166
167 s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
168 #endif
169 if (err != Z_OK || s->outbuf == Z_NULL) {
170 return destroy(s), (gzFile)Z_NULL;
171 }
172 } else {
173 s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
174
175 err = inflateInit2(&(s->stream), -MAX_WBITS);
176 /* windowBits is passed < 0 to tell that there is no zlib header.
177 * Note that in this case inflate *requires* an extra "dummy" byte
178 * after the compressed stream in order to complete decompression and
179 * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
180 * present after the compressed stream.
181 */
182 if (err != Z_OK || s->inbuf == Z_NULL) {
183 return destroy(s), (gzFile)Z_NULL;
184 }
185 }
186 s->stream.avail_out = Z_BUFSIZE;
187
188 errno = 0;
189 s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
190
191 if (s->file == NULL) {
192 return destroy(s), (gzFile)Z_NULL;
193 }
194 if (s->mode == 'w') {
195 /* Write a very simple .gz header:
196 */
197 fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
198 Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
199 s->start = 10L;
200 /* We use 10L instead of ftell(s->file) to because ftell causes an
201 * fflush on some systems. This version of the library doesn't use
202 * start anyway in write mode, so this initialization is not
203 * necessary.
204 */
205 } else {
206 check_header(s); /* skip the .gz header */
207 s->start = ftell(s->file) - s->stream.avail_in;
208 }
209
210 return (gzFile)s;
211 }
212
213 /* ===========================================================================
214 Opens a gzip (.gz) file for reading or writing.
215 */
gzopen(path,mode)216 gzFile ZEXPORT gzopen (path, mode)
217 const char *path;
218 const char *mode;
219 {
220 return gz_open (path, mode, -1);
221 }
222
223 /* ===========================================================================
224 Associate a gzFile with the file descriptor fd. fd is not dup'ed here
225 to mimic the behavio(u)r of fdopen.
226 */
gzdopen(fd,mode)227 gzFile ZEXPORT gzdopen (fd, mode)
228 int fd;
229 const char *mode;
230 {
231 char name[46]; /* allow for up to 128-bit integers */
232
233 if (fd < 0) return (gzFile)Z_NULL;
234 sprintf(name, "<fd:%d>", fd); /* for debugging */
235
236 return gz_open (name, mode, fd);
237 }
238
239 /* ===========================================================================
240 * Update the compression level and strategy
241 */
gzsetparams(file,level,strategy)242 int ZEXPORT gzsetparams (file, level, strategy)
243 gzFile file;
244 int level;
245 int strategy;
246 {
247 gz_stream *s = (gz_stream*)file;
248
249 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
250
251 /* Make room to allow flushing */
252 if (s->stream.avail_out == 0) {
253
254 s->stream.next_out = s->outbuf;
255 if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
256 s->z_err = Z_ERRNO;
257 }
258 s->stream.avail_out = Z_BUFSIZE;
259 }
260
261 return deflateParams (&(s->stream), level, strategy);
262 }
263
264 /* ===========================================================================
265 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
266 for end of file.
267 IN assertion: the stream s has been sucessfully opened for reading.
268 */
get_byte(s)269 local int get_byte(s)
270 gz_stream *s;
271 {
272 if (s->z_eof) return EOF;
273 if (s->stream.avail_in == 0) {
274 errno = 0;
275 s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
276 if (s->stream.avail_in == 0) {
277 s->z_eof = 1;
278 if (ferror(s->file)) s->z_err = Z_ERRNO;
279 return EOF;
280 }
281 s->stream.next_in = s->inbuf;
282 }
283 s->stream.avail_in--;
284 return *(s->stream.next_in)++;
285 }
286
287 /* ===========================================================================
288 Check the gzip header of a gz_stream opened for reading. Set the stream
289 mode to transparent if the gzip magic header is not present; set s->err
290 to Z_DATA_ERROR if the magic header is present but the rest of the header
291 is incorrect.
292 IN assertion: the stream s has already been created sucessfully;
293 s->stream.avail_in is zero for the first time, but may be non-zero
294 for concatenated .gz files.
295 */
check_header(s)296 local void check_header(s)
297 gz_stream *s;
298 {
299 int method; /* method byte */
300 int flags; /* flags byte */
301 uInt len;
302 int c;
303
304 /* Assure two bytes in the buffer so we can peek ahead -- handle case
305 where first byte of header is at the end of the buffer after the last
306 gzip segment */
307 len = s->stream.avail_in;
308 if (len < 2) {
309 if (len) s->inbuf[0] = s->stream.next_in[0];
310 errno = 0;
311 len = (uInt)fread(s->inbuf + len, 1, (size_t)(Z_BUFSIZE >> len),
312 s->file);
313 if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
314 s->stream.avail_in += len;
315 s->stream.next_in = s->inbuf;
316 if (s->stream.avail_in < 2) {
317 s->transparent = s->stream.avail_in;
318 return;
319 }
320 }
321
322 /* Peek ahead to check the gzip magic header */
323 if (s->stream.next_in[0] != gz_magic[0] ||
324 s->stream.next_in[1] != gz_magic[1]) {
325 s->transparent = 1;
326 return;
327 }
328 s->stream.avail_in -= 2;
329 s->stream.next_in += 2;
330
331 /* Check the rest of the gzip header */
332 method = get_byte(s);
333 flags = get_byte(s);
334 if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
335 s->z_err = Z_DATA_ERROR;
336 return;
337 }
338
339 /* Discard time, xflags and OS code: */
340 for (len = 0; len < 6; len++) (void)get_byte(s);
341
342 if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
343 len = (uInt)get_byte(s);
344 len += ((uInt)get_byte(s))<<8;
345 /* len is garbage if EOF but the loop below will quit anyway */
346 while (len-- != 0 && get_byte(s) != EOF) ;
347 }
348 if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
349 while ((c = get_byte(s)) != 0 && c != EOF) ;
350 }
351 if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
352 while ((c = get_byte(s)) != 0 && c != EOF) ;
353 }
354 if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
355 for (len = 0; len < 2; len++) (void)get_byte(s);
356 }
357 s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
358 }
359
360 /* ===========================================================================
361 * Cleanup then free the given gz_stream. Return a zlib error code.
362 Try freeing in the reverse order of allocations.
363 */
destroy(s)364 local int destroy (s)
365 gz_stream *s;
366 {
367 int err = Z_OK;
368
369 if (!s) return Z_STREAM_ERROR;
370
371 TRYFREE(s->msg);
372
373 if (s->stream.state != NULL) {
374 if (s->mode == 'w') {
375 #ifdef NO_GZCOMPRESS
376 err = Z_STREAM_ERROR;
377 #else
378 err = deflateEnd(&(s->stream));
379 #endif
380 } else if (s->mode == 'r') {
381 err = inflateEnd(&(s->stream));
382 }
383 }
384 if (s->file != NULL && fclose(s->file)) {
385 #ifdef ESPIPE
386 if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
387 #endif
388 err = Z_ERRNO;
389 }
390 if (s->z_err < 0) err = s->z_err;
391
392 TRYFREE(s->inbuf);
393 TRYFREE(s->outbuf);
394 TRYFREE(s->path);
395 TRYFREE(s);
396 return err;
397 }
398
399 /* ===========================================================================
400 Reads the given number of uncompressed bytes from the compressed file.
401 gzread returns the number of bytes actually read (0 for end of file).
402 */
gzread(file,buf,len)403 int ZEXPORT gzread (file, buf, len)
404 gzFile file;
405 voidp buf;
406 unsigned len;
407 {
408 gz_stream *s = (gz_stream*)file;
409 Bytef *start = (Bytef*)buf; /* starting point for crc computation */
410 Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */
411
412 if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
413
414 if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
415 if (s->z_err == Z_STREAM_END) return 0; /* EOF */
416
417 next_out = (Byte*)buf;
418 s->stream.next_out = (Bytef*)buf;
419 s->stream.avail_out = len;
420
421 if (s->stream.avail_out && s->back != EOF) {
422 *next_out++ = s->back;
423 s->stream.next_out++;
424 s->stream.avail_out--;
425 s->back = EOF;
426 s->out++;
427 start++;
428 if (s->last) {
429 s->z_err = Z_STREAM_END;
430 return 1;
431 }
432 }
433
434 while (s->stream.avail_out != 0) {
435
436 if (s->transparent) {
437 /* Copy first the lookahead bytes: */
438 uInt n = s->stream.avail_in;
439 if (n > s->stream.avail_out) n = s->stream.avail_out;
440 if (n > 0) {
441 zmemcpy(s->stream.next_out, s->stream.next_in, n);
442 next_out += n;
443 s->stream.next_out = next_out;
444 s->stream.next_in += n;
445 s->stream.avail_out -= n;
446 s->stream.avail_in -= n;
447 }
448 if (s->stream.avail_out > 0) {
449 s->stream.avail_out -=
450 (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
451 }
452 len -= s->stream.avail_out;
453 s->in += len;
454 s->out += len;
455 if (len == 0) s->z_eof = 1;
456 return (int)len;
457 }
458 if (s->stream.avail_in == 0 && !s->z_eof) {
459
460 errno = 0;
461 s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
462 if (s->stream.avail_in == 0) {
463 s->z_eof = 1;
464 if (ferror(s->file)) {
465 s->z_err = Z_ERRNO;
466 break;
467 }
468 }
469 s->stream.next_in = s->inbuf;
470 }
471 s->in += s->stream.avail_in;
472 s->out += s->stream.avail_out;
473 s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
474 s->in -= s->stream.avail_in;
475 s->out -= s->stream.avail_out;
476
477 if (s->z_err == Z_STREAM_END) {
478 /* Check CRC and original size */
479 s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
480 start = s->stream.next_out;
481
482 if (getLong(s) != s->crc) {
483 s->z_err = Z_DATA_ERROR;
484 } else {
485 (void)getLong(s);
486 /* The uncompressed length returned by above getlong() may be
487 * different from s->out in case of concatenated .gz files.
488 * Check for such files:
489 */
490 check_header(s);
491 if (s->z_err == Z_OK) {
492 inflateReset(&(s->stream));
493 s->crc = crc32(0L, Z_NULL, 0);
494 }
495 }
496 }
497 if (s->z_err != Z_OK || s->z_eof) break;
498 }
499 s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
500
501 if (len == s->stream.avail_out &&
502 (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
503 return -1;
504 return (int)(len - s->stream.avail_out);
505 }
506
507
508 /* ===========================================================================
509 Reads one byte from the compressed file. gzgetc returns this byte
510 or -1 in case of end of file or error.
511 */
gzgetc(file)512 int ZEXPORT gzgetc(file)
513 gzFile file;
514 {
515 unsigned char c;
516
517 return gzread(file, &c, 1) == 1 ? c : -1;
518 }
519
520
521 /* ===========================================================================
522 Push one byte back onto the stream.
523 */
gzungetc(c,file)524 int ZEXPORT gzungetc(c, file)
525 int c;
526 gzFile file;
527 {
528 gz_stream *s = (gz_stream*)file;
529
530 if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
531 s->back = c;
532 s->out--;
533 s->last = (s->z_err == Z_STREAM_END);
534 if (s->last) s->z_err = Z_OK;
535 s->z_eof = 0;
536 return c;
537 }
538
539
540 /* ===========================================================================
541 Reads bytes from the compressed file until len-1 characters are
542 read, or a newline character is read and transferred to buf, or an
543 end-of-file condition is encountered. The string is then terminated
544 with a null character.
545 gzgets returns buf, or Z_NULL in case of error.
546
547 The current implementation is not optimized at all.
548 */
gzgets(file,buf,len)549 char * ZEXPORT gzgets(file, buf, len)
550 gzFile file;
551 char *buf;
552 int len;
553 {
554 char *b = buf;
555 if (buf == Z_NULL || len <= 0) return Z_NULL;
556
557 while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
558 *buf = '\0';
559 return b == buf && len > 0 ? Z_NULL : b;
560 }
561
562
563 #ifndef NO_GZCOMPRESS
564 /* ===========================================================================
565 Writes the given number of uncompressed bytes into the compressed file.
566 gzwrite returns the number of bytes actually written (0 in case of error).
567 */
gzwrite(file,buf,len)568 int ZEXPORT gzwrite (file, buf, len)
569 gzFile file;
570 voidpc buf;
571 unsigned len;
572 {
573 gz_stream *s = (gz_stream*)file;
574
575 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
576
577 s->stream.next_in = __UNCONST(buf);
578 s->stream.avail_in = len;
579
580 while (s->stream.avail_in != 0) {
581
582 if (s->stream.avail_out == 0) {
583
584 s->stream.next_out = s->outbuf;
585 if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
586 s->z_err = Z_ERRNO;
587 break;
588 }
589 s->stream.avail_out = Z_BUFSIZE;
590 }
591 s->in += s->stream.avail_in;
592 s->out += s->stream.avail_out;
593 s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
594 s->in -= s->stream.avail_in;
595 s->out -= s->stream.avail_out;
596 if (s->z_err != Z_OK) break;
597 }
598 s->crc = crc32(s->crc, (const Bytef *)buf, len);
599
600 return (int)(len - s->stream.avail_in);
601 }
602
603
604 /* ===========================================================================
605 Converts, formats, and writes the args to the compressed file under
606 control of the format string, as in fprintf. gzprintf returns the number of
607 uncompressed bytes actually written (0 in case of error).
608 */
609 #ifdef STDC
610 #include <stdarg.h>
611
gzprintf(gzFile file,const char * format,...)612 int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
613 {
614 char buf[Z_PRINTF_BUFSIZE];
615 va_list va;
616 int len;
617
618 buf[sizeof(buf) - 1] = 0;
619 va_start(va, format);
620 #ifdef NO_vsnprintf
621 # ifdef HAS_vsprintf_void
622 (void)vsprintf(buf, format, va);
623 va_end(va);
624 for (len = 0; len < sizeof(buf); len++)
625 if (buf[len] == 0) break;
626 # else
627 len = vsprintf(buf, format, va);
628 va_end(va);
629 # endif
630 #else
631 # ifdef HAS_vsnprintf_void
632 (void)vsnprintf(buf, sizeof(buf), format, va);
633 va_end(va);
634 len = strlen(buf);
635 # else
636 len = vsnprintf(buf, sizeof(buf), format, va);
637 va_end(va);
638 # endif
639 #endif
640 if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
641 return 0;
642 return gzwrite(file, buf, (unsigned)len);
643 }
644 #else /* not ANSI C */
645
gzprintf(file,format,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20)646 int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
647 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
648 gzFile file;
649 const char *format;
650 int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
651 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
652 {
653 char buf[Z_PRINTF_BUFSIZE];
654 int len;
655
656 buf[sizeof(buf) - 1] = 0;
657 #ifdef NO_snprintf
658 # ifdef HAS_sprintf_void
659 sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
660 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
661 for (len = 0; len < sizeof(buf); len++)
662 if (buf[len] == 0) break;
663 # else
664 len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
665 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
666 # endif
667 #else
668 # ifdef HAS_snprintf_void
669 snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
670 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
671 len = strlen(buf);
672 # else
673 len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
674 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
675 # endif
676 #endif
677 if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
678 return 0;
679 return gzwrite(file, buf, len);
680 }
681 #endif
682
683 /* ===========================================================================
684 Writes c, converted to an unsigned char, into the compressed file.
685 gzputc returns the value that was written, or -1 in case of error.
686 */
gzputc(file,c)687 int ZEXPORT gzputc(file, c)
688 gzFile file;
689 int c;
690 {
691 unsigned char cc = (unsigned char) c; /* required for big endian systems */
692
693 return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
694 }
695
696
697 /* ===========================================================================
698 Writes the given null-terminated string to the compressed file, excluding
699 the terminating null character.
700 gzputs returns the number of characters written, or -1 in case of error.
701 */
gzputs(file,s)702 int ZEXPORT gzputs(file, s)
703 gzFile file;
704 const char *s;
705 {
706 return gzwrite(file, __UNCONST(s), (unsigned)strlen(s));
707 }
708
709
710 /* ===========================================================================
711 Flushes all pending output into the compressed file. The parameter
712 flush is as in the deflate() function.
713 */
do_flush(file,flush)714 local int do_flush (file, flush)
715 gzFile file;
716 int flush;
717 {
718 uInt len;
719 int done = 0;
720 gz_stream *s = (gz_stream*)file;
721
722 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
723
724 s->stream.avail_in = 0; /* should be zero already anyway */
725
726 for (;;) {
727 len = Z_BUFSIZE - s->stream.avail_out;
728
729 if (len != 0) {
730 if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
731 s->z_err = Z_ERRNO;
732 return Z_ERRNO;
733 }
734 s->stream.next_out = s->outbuf;
735 s->stream.avail_out = Z_BUFSIZE;
736 }
737 if (done) break;
738 s->out += s->stream.avail_out;
739 s->z_err = deflate(&(s->stream), flush);
740 s->out -= s->stream.avail_out;
741
742 /* Ignore the second of two consecutive flushes: */
743 if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
744
745 /* deflate has finished flushing only when it hasn't used up
746 * all the available space in the output buffer:
747 */
748 done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
749
750 if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
751 }
752 return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
753 }
754
gzflush(file,flush)755 int ZEXPORT gzflush (file, flush)
756 gzFile file;
757 int flush;
758 {
759 gz_stream *s = (gz_stream*)file;
760 int err = do_flush (file, flush);
761
762 if (err) return err;
763 fflush(s->file);
764 return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
765 }
766 #endif /* NO_GZCOMPRESS */
767
768 /* ===========================================================================
769 Sets the starting position for the next gzread or gzwrite on the given
770 compressed file. The offset represents a number of bytes in the
771 gzseek returns the resulting offset location as measured in bytes from
772 the beginning of the uncompressed stream, or -1 in case of error.
773 SEEK_END is not implemented, returns error.
774 In this version of the library, gzseek can be extremely slow.
775 */
gzseek(file,offset,whence)776 z_off_t ZEXPORT gzseek (file, offset, whence)
777 gzFile file;
778 z_off_t offset;
779 int whence;
780 {
781 gz_stream *s = (gz_stream*)file;
782
783 if (s == NULL || whence == SEEK_END ||
784 s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
785 return -1L;
786 }
787
788 if (s->mode == 'w') {
789 #ifdef NO_GZCOMPRESS
790 return -1L;
791 #else
792 if (whence == SEEK_SET) {
793 offset -= s->in;
794 }
795 if (offset < 0) return -1L;
796
797 /* At this point, offset is the number of zero bytes to write. */
798 if (s->inbuf == Z_NULL) {
799 s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
800 if (s->inbuf == Z_NULL) return -1L;
801 zmemzero(s->inbuf, Z_BUFSIZE);
802 }
803 while (offset > 0) {
804 uInt size = Z_BUFSIZE;
805 if (offset < Z_BUFSIZE) size = (uInt)offset;
806
807 size = gzwrite(file, s->inbuf, size);
808 if (size == 0) return -1L;
809
810 offset -= size;
811 }
812 return s->in;
813 #endif
814 }
815 /* Rest of function is for reading only */
816
817 /* compute absolute position */
818 if (whence == SEEK_CUR) {
819 offset += s->out;
820 }
821 if (offset < 0) return -1L;
822
823 if (s->transparent) {
824 /* map to fseek */
825 s->back = EOF;
826 s->stream.avail_in = 0;
827 s->stream.next_in = s->inbuf;
828 if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
829
830 s->in = s->out = offset;
831 return offset;
832 }
833
834 /* For a negative seek, rewind and use positive seek */
835 if (offset >= s->out) {
836 offset -= s->out;
837 } else if (gzrewind(file) < 0) {
838 return -1L;
839 }
840 /* offset is now the number of bytes to skip. */
841
842 if (offset != 0 && s->outbuf == Z_NULL) {
843 s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
844 if (s->outbuf == Z_NULL) return -1L;
845 }
846 if (offset && s->back != EOF) {
847 s->back = EOF;
848 s->out++;
849 offset--;
850 if (s->last) s->z_err = Z_STREAM_END;
851 }
852 while (offset > 0) {
853 int size = Z_BUFSIZE;
854 if (offset < Z_BUFSIZE) size = (int)offset;
855
856 size = gzread(file, s->outbuf, (uInt)size);
857 if (size <= 0) return -1L;
858 offset -= size;
859 }
860 return s->out;
861 }
862
863 /* ===========================================================================
864 Rewinds input file.
865 */
gzrewind(file)866 int ZEXPORT gzrewind (file)
867 gzFile file;
868 {
869 gz_stream *s = (gz_stream*)file;
870
871 if (s == NULL || s->mode != 'r') return -1;
872
873 s->z_err = Z_OK;
874 s->z_eof = 0;
875 s->back = EOF;
876 s->stream.avail_in = 0;
877 s->stream.next_in = s->inbuf;
878 s->crc = crc32(0L, Z_NULL, 0);
879 if (!s->transparent) (void)inflateReset(&s->stream);
880 s->in = 0;
881 s->out = 0;
882 return fseek(s->file, s->start, SEEK_SET);
883 }
884
885 /* ===========================================================================
886 Returns the starting position for the next gzread or gzwrite on the
887 given compressed file. This position represents a number of bytes in the
888 uncompressed data stream.
889 */
gztell(file)890 z_off_t ZEXPORT gztell (file)
891 gzFile file;
892 {
893 return gzseek(file, 0L, SEEK_CUR);
894 }
895
896 /* ===========================================================================
897 Returns 1 when EOF has previously been detected reading the given
898 input stream, otherwise zero.
899 */
gzeof(file)900 int ZEXPORT gzeof (file)
901 gzFile file;
902 {
903 gz_stream *s = (gz_stream*)file;
904
905 /* With concatenated compressed files that can have embedded
906 * crc trailers, z_eof is no longer the only/best indicator of EOF
907 * on a gz_stream. Handle end-of-stream error explicitly here.
908 */
909 if (s == NULL || s->mode != 'r') return 0;
910 if (s->z_eof) return 1;
911 return s->z_err == Z_STREAM_END;
912 }
913
914 /* ===========================================================================
915 Returns 1 if reading and doing so transparently, otherwise zero.
916 */
gzdirect(file)917 int ZEXPORT gzdirect (file)
918 gzFile file;
919 {
920 gz_stream *s = (gz_stream*)file;
921
922 if (s == NULL || s->mode != 'r') return 0;
923 return s->transparent;
924 }
925
926 #ifndef NO_GZCOMPRESS
927 /* ===========================================================================
928 Outputs a long in LSB order to the given file
929 */
putLong(file,x)930 local void putLong (file, x)
931 FILE *file;
932 uLong x;
933 {
934 int n;
935 for (n = 0; n < 4; n++) {
936 fputc((int)(x & 0xff), file);
937 x >>= 8;
938 }
939 }
940 #endif
941
942 /* ===========================================================================
943 Reads a long in LSB order from the given gz_stream. Sets z_err in case
944 of error.
945 */
getLong(s)946 local uLong getLong (s)
947 gz_stream *s;
948 {
949 uLong x = (uLong)get_byte(s);
950 int c;
951
952 x += ((uLong)get_byte(s))<<8;
953 x += ((uLong)get_byte(s))<<16;
954 c = get_byte(s);
955 if (c == EOF) s->z_err = Z_DATA_ERROR;
956 x += ((uLong)c)<<24;
957 return x;
958 }
959
960 /* ===========================================================================
961 Flushes all pending output if necessary, closes the compressed file
962 and deallocates all the (de)compression state.
963 */
gzclose(file)964 int ZEXPORT gzclose (file)
965 gzFile file;
966 {
967 gz_stream *s = (gz_stream*)file;
968
969 if (s == NULL) return Z_STREAM_ERROR;
970
971 if (s->mode == 'w') {
972 #ifdef NO_GZCOMPRESS
973 return Z_STREAM_ERROR;
974 #else
975 if (do_flush (file, Z_FINISH) != Z_OK)
976 return destroy((gz_stream*)file);
977
978 putLong (s->file, s->crc);
979 putLong (s->file, (uLong)(s->in & 0xffffffff));
980 #endif
981 }
982 return destroy((gz_stream*)file);
983 }
984
985 #ifdef STDC
986 # define zstrerror(errnum) strerror(errnum)
987 #else
988 # define zstrerror(errnum) ""
989 #endif
990
991 /* ===========================================================================
992 Returns the error message for the last error which occurred on the
993 given compressed file. errnum is set to zlib error number. If an
994 error occurred in the file system and not in the compression library,
995 errnum is set to Z_ERRNO and the application may consult errno
996 to get the exact error code.
997 */
gzerror(file,errnum)998 const char * ZEXPORT gzerror (file, errnum)
999 gzFile file;
1000 int *errnum;
1001 {
1002 const char *m;
1003 gz_stream *s = (gz_stream*)file;
1004
1005 if (s == NULL) {
1006 *errnum = Z_STREAM_ERROR;
1007 return (const char*)ERR_MSG(Z_STREAM_ERROR);
1008 }
1009 *errnum = s->z_err;
1010 if (*errnum == Z_OK) return (const char*)"";
1011
1012 m = *errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg;
1013
1014 if (m == NULL || *m == '\0') m = ERR_MSG(s->z_err);
1015
1016 TRYFREE(s->msg);
1017 s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
1018 if (s->msg == Z_NULL) return ERR_MSG(Z_MEM_ERROR);
1019 strcpy(s->msg, s->path);
1020 strcat(s->msg, ": ");
1021 strcat(s->msg, m);
1022 return (const char*)s->msg;
1023 }
1024
1025 /* ===========================================================================
1026 Clear the error and end-of-file flags, and do the same for the real file.
1027 */
gzclearerr(file)1028 void ZEXPORT gzclearerr (file)
1029 gzFile file;
1030 {
1031 gz_stream *s = (gz_stream*)file;
1032
1033 if (s == NULL) return;
1034 if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
1035 s->z_eof = 0;
1036 clearerr(s->file);
1037 }
1038