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