1 /* gzio.c -- IO on .gz files
2 * Copyright (C) 1995-2003 Jean-loup Gailly.
3 * For conditions of distribution and use, see copyright notice in zlib.h
5 * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.
8 /* @(#) $Id: gzio.c,v 1.1 2005/02/27 23:15:39 hpa Exp $ */
14 #ifdef NO_DEFLATE /* for compatiblity with old definition */
15 # define NO_GZCOMPRESS
19 struct internal_state {int dummy;}; /* for buggy compilers */
24 # define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
26 # define Z_BUFSIZE 16384
29 #ifndef Z_PRINTF_BUFSIZE
30 # define Z_PRINTF_BUFSIZE 4096
34 # pragma map (fdopen , "\174\174FDOPEN")
35 FILE *fdopen(int, const char *);
39 extern voidp malloc OF((uInt size));
40 extern void free OF((voidpf ptr));
43 #define ALLOC(size) malloc(size)
44 #define TRYFREE(p) {if (p) free(p);}
46 static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
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 */
56 typedef struct gz_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 */
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));
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).
93 local gzFile gz_open (path, mode, fd)
99 int level = Z_DEFAULT_COMPRESSION; /* compression level */
100 int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
101 char *p = (char*)mode;
103 char fmode[80]; /* copy of mode, without the compression level */
106 if (!path || !mode) return Z_NULL;
108 s = (gz_stream *)ALLOC(sizeof(gz_stream));
109 if (!s) return Z_NULL;
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;
123 s->crc = crc32(0L, Z_NULL, 0);
127 s->path = (char*)ALLOC(strlen(path)+1);
128 if (s->path == NULL) {
129 return destroy(s), (gzFile)Z_NULL;
131 strcpy(s->path, path); /* do this early for debugging */
135 if (*p == 'r') s->mode = 'r';
136 if (*p == 'w' || *p == 'a') s->mode = 'w';
137 if (*p >= '0' && *p <= '9') {
139 } else if (*p == 'f') {
140 strategy = Z_FILTERED;
141 } else if (*p == 'h') {
142 strategy = Z_HUFFMAN_ONLY;
143 } else if (*p == 'R') {
146 *m++ = *p; /* copy the mode */
148 } while (*p++ && m != fmode + sizeof(fmode));
149 if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
151 if (s->mode == 'w') {
153 err = Z_STREAM_ERROR;
155 err = deflateInit2(&(s->stream), level,
156 Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
157 /* windowBits is passed < 0 to suppress zlib header */
159 s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
161 if (err != Z_OK || s->outbuf == Z_NULL) {
162 return destroy(s), (gzFile)Z_NULL;
165 s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
167 err = inflateInit2(&(s->stream), -MAX_WBITS);
168 /* windowBits is passed < 0 to tell that there is no zlib header.
169 * Note that in this case inflate *requires* an extra "dummy" byte
170 * after the compressed stream in order to complete decompression and
171 * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
172 * present after the compressed stream.
174 if (err != Z_OK || s->inbuf == Z_NULL) {
175 return destroy(s), (gzFile)Z_NULL;
178 s->stream.avail_out = Z_BUFSIZE;
181 s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
183 if (s->file == NULL) {
184 return destroy(s), (gzFile)Z_NULL;
186 if (s->mode == 'w') {
187 /* Write a very simple .gz header:
189 fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
190 Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
192 /* We use 10L instead of ftell(s->file) to because ftell causes an
193 * fflush on some systems. This version of the library doesn't use
194 * start anyway in write mode, so this initialization is not
198 check_header(s); /* skip the .gz header */
199 s->start = ftell(s->file) - s->stream.avail_in;
205 /* ===========================================================================
206 Opens a gzip (.gz) file for reading or writing.
208 gzFile ZEXPORT gzopen (path, mode)
212 return gz_open (path, mode, -1);
215 /* ===========================================================================
216 Associate a gzFile with the file descriptor fd. fd is not dup'ed here
217 to mimic the behavio(u)r of fdopen.
219 gzFile ZEXPORT gzdopen (fd, mode)
225 if (fd < 0) return (gzFile)Z_NULL;
226 sprintf(name, "<fd:%d>", fd); /* for debugging */
228 return gz_open (name, mode, fd);
231 /* ===========================================================================
232 * Update the compression level and strategy
234 int ZEXPORT gzsetparams (file, level, strategy)
239 gz_stream *s = (gz_stream*)file;
241 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
243 /* Make room to allow flushing */
244 if (s->stream.avail_out == 0) {
246 s->stream.next_out = s->outbuf;
247 if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
250 s->stream.avail_out = Z_BUFSIZE;
253 return deflateParams (&(s->stream), level, strategy);
256 /* ===========================================================================
257 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
259 IN assertion: the stream s has been sucessfully opened for reading.
261 local int get_byte(s)
264 if (s->z_eof) return EOF;
265 if (s->stream.avail_in == 0) {
267 s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
268 if (s->stream.avail_in == 0) {
271 if (errno) s->z_err = Z_ERRNO;
274 s->stream.next_in = s->inbuf;
276 s->stream.avail_in--;
277 return *(s->stream.next_in)++;
280 /* ===========================================================================
281 Check the gzip header of a gz_stream opened for reading. Set the stream
282 mode to transparent if the gzip magic header is not present; set s->err
283 to Z_DATA_ERROR if the magic header is present but the rest of the header
285 IN assertion: the stream s has already been created sucessfully;
286 s->stream.avail_in is zero for the first time, but may be non-zero
287 for concatenated .gz files.
289 local void check_header(s)
292 int method; /* method byte */
293 int flags; /* flags byte */
297 /* Assure two bytes in the buffer so we can peek ahead -- handle case
298 where first byte of header is at the end of the buffer after the last
300 len = s->stream.avail_in;
302 if (len) s->inbuf[0] = s->stream.next_in[0];
304 len = fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
306 if (len == 0 && errno) 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;
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]) {
321 s->stream.avail_in -= 2;
322 s->stream.next_in += 2;
324 /* Check the rest of the gzip header */
325 method = get_byte(s);
327 if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
328 s->z_err = Z_DATA_ERROR;
332 /* Discard time, xflags and OS code: */
333 for (len = 0; len < 6; len++) (void)get_byte(s);
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) ;
341 if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
342 while ((c = get_byte(s)) != 0 && c != EOF) ;
344 if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
345 while ((c = get_byte(s)) != 0 && c != EOF) ;
347 if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
348 for (len = 0; len < 2; len++) (void)get_byte(s);
350 s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
353 /* ===========================================================================
354 * Cleanup then free the given gz_stream. Return a zlib error code.
355 Try freeing in the reverse order of allocations.
357 local int destroy (s)
362 if (!s) return Z_STREAM_ERROR;
366 if (s->stream.state != NULL) {
367 if (s->mode == 'w') {
369 err = Z_STREAM_ERROR;
371 err = deflateEnd(&(s->stream));
373 } else if (s->mode == 'r') {
374 err = inflateEnd(&(s->stream));
377 if (s->file != NULL && fclose(s->file)) {
379 if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
383 if (s->z_err < 0) err = s->z_err;
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).
396 int ZEXPORT gzread (file, buf, len)
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) */
405 if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
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 */
410 next_out = (Byte*)buf;
411 s->stream.next_out = (Bytef*)buf;
412 s->stream.avail_out = len;
414 if (s->stream.avail_out && s->back != EOF) {
415 *next_out++ = s->back;
416 s->stream.next_out++;
417 s->stream.avail_out--;
421 s->z_err = Z_STREAM_END;
426 while (s->stream.avail_out != 0) {
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;
433 zmemcpy(s->stream.next_out, s->stream.next_in, 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;
440 if (s->stream.avail_out > 0) {
441 s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out,
444 len -= s->stream.avail_out;
447 if (len == 0) s->z_eof = 1;
450 if (s->stream.avail_in == 0 && !s->z_eof) {
453 s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
454 if (s->stream.avail_in == 0) {
461 s->stream.next_in = s->inbuf;
463 s->in += s->stream.avail_in;
464 s->out += s->stream.avail_out;
465 s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
466 s->in -= s->stream.avail_in;
467 s->out -= s->stream.avail_out;
469 if (s->z_err == Z_STREAM_END) {
470 /* Check CRC and original size */
471 s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
472 start = s->stream.next_out;
474 if (getLong(s) != s->crc) {
475 s->z_err = Z_DATA_ERROR;
478 /* The uncompressed length returned by above getlong() may be
479 * different from s->out in case of concatenated .gz files.
480 * Check for such files:
483 if (s->z_err == Z_OK) {
484 inflateReset(&(s->stream));
485 s->crc = crc32(0L, Z_NULL, 0);
489 if (s->z_err != Z_OK || s->z_eof) break;
491 s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
493 return (int)(len - s->stream.avail_out);
497 /* ===========================================================================
498 Reads one byte from the compressed file. gzgetc returns this byte
499 or -1 in case of end of file or error.
501 int ZEXPORT gzgetc(file)
506 return gzread(file, &c, 1) == 1 ? c : -1;
510 /* ===========================================================================
511 Push one byte back onto the stream.
513 int ZEXPORT gzungetc(c, file)
517 gz_stream *s = (gz_stream*)file;
519 if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
522 s->last = (s->z_err == Z_STREAM_END);
523 if (s->last) s->z_err = Z_OK;
529 /* ===========================================================================
530 Reads bytes from the compressed file until len-1 characters are
531 read, or a newline character is read and transferred to buf, or an
532 end-of-file condition is encountered. The string is then terminated
533 with a null character.
534 gzgets returns buf, or Z_NULL in case of error.
536 The current implementation is not optimized at all.
538 char * ZEXPORT gzgets(file, buf, len)
544 if (buf == Z_NULL || len <= 0) return Z_NULL;
546 while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
548 return b == buf && len > 0 ? Z_NULL : b;
552 #ifndef NO_GZCOMPRESS
553 /* ===========================================================================
554 Writes the given number of uncompressed bytes into the compressed file.
555 gzwrite returns the number of bytes actually written (0 in case of error).
557 int ZEXPORT gzwrite (file, buf, len)
562 gz_stream *s = (gz_stream*)file;
564 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
566 s->stream.next_in = (Bytef*)buf;
567 s->stream.avail_in = len;
569 while (s->stream.avail_in != 0) {
571 if (s->stream.avail_out == 0) {
573 s->stream.next_out = s->outbuf;
574 if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
578 s->stream.avail_out = Z_BUFSIZE;
580 s->in += s->stream.avail_in;
581 s->out += s->stream.avail_out;
582 s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
583 s->in -= s->stream.avail_in;
584 s->out -= s->stream.avail_out;
585 if (s->z_err != Z_OK) break;
587 s->crc = crc32(s->crc, (const Bytef *)buf, len);
589 return (int)(len - s->stream.avail_in);
593 /* ===========================================================================
594 Converts, formats, and writes the args to the compressed file under
595 control of the format string, as in fprintf. gzprintf returns the number of
596 uncompressed bytes actually written (0 in case of error).
601 int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
603 char buf[Z_PRINTF_BUFSIZE];
607 buf[sizeof(buf) - 1] = 0;
608 va_start(va, format);
610 # ifdef HAS_vsprintf_void
611 (void)vsprintf(buf, format, va);
613 for (len = 0; len < sizeof(buf); len++)
614 if (buf[len] == 0) break;
616 len = vsprintf(buf, format, va);
620 # ifdef HAS_vsnprintf_void
621 (void)vsnprintf(buf, sizeof(buf), format, va);
625 len = vsnprintf(buf, sizeof(buf), format, va);
629 if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
631 return gzwrite(file, buf, (unsigned)len);
633 #else /* not ANSI C */
635 int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
636 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
639 int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
640 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
642 char buf[Z_PRINTF_BUFSIZE];
645 buf[sizeof(buf) - 1] = 0;
647 # ifdef HAS_sprintf_void
648 sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
649 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
650 for (len = 0; len < sizeof(buf); len++)
651 if (buf[len] == 0) break;
653 len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
654 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
657 # ifdef HAS_snprintf_void
658 snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
659 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
662 len = 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);
666 if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
668 return gzwrite(file, buf, len);
672 /* ===========================================================================
673 Writes c, converted to an unsigned char, into the compressed file.
674 gzputc returns the value that was written, or -1 in case of error.
676 int ZEXPORT gzputc(file, c)
680 unsigned char cc = (unsigned char) c; /* required for big endian systems */
682 return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
686 /* ===========================================================================
687 Writes the given null-terminated string to the compressed file, excluding
688 the terminating null character.
689 gzputs returns the number of characters written, or -1 in case of error.
691 int ZEXPORT gzputs(file, s)
695 return gzwrite(file, (char*)s, (unsigned)strlen(s));
699 /* ===========================================================================
700 Flushes all pending output into the compressed file. The parameter
701 flush is as in the deflate() function.
703 local int do_flush (file, flush)
709 gz_stream *s = (gz_stream*)file;
711 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
713 s->stream.avail_in = 0; /* should be zero already anyway */
716 len = Z_BUFSIZE - s->stream.avail_out;
719 if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
723 s->stream.next_out = s->outbuf;
724 s->stream.avail_out = Z_BUFSIZE;
727 s->out += s->stream.avail_out;
728 s->z_err = deflate(&(s->stream), flush);
729 s->out -= s->stream.avail_out;
731 /* Ignore the second of two consecutive flushes: */
732 if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
734 /* deflate has finished flushing only when it hasn't used up
735 * all the available space in the output buffer:
737 done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
739 if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
741 return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
744 int ZEXPORT gzflush (file, flush)
748 gz_stream *s = (gz_stream*)file;
749 int err = do_flush (file, flush);
753 return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
755 #endif /* NO_GZCOMPRESS */
757 /* ===========================================================================
758 Sets the starting position for the next gzread or gzwrite on the given
759 compressed file. The offset represents a number of bytes in the
760 gzseek returns the resulting offset location as measured in bytes from
761 the beginning of the uncompressed stream, or -1 in case of error.
762 SEEK_END is not implemented, returns error.
763 In this version of the library, gzseek can be extremely slow.
765 z_off_t ZEXPORT gzseek (file, offset, whence)
770 gz_stream *s = (gz_stream*)file;
772 if (s == NULL || whence == SEEK_END ||
773 s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
777 if (s->mode == 'w') {
781 if (whence == SEEK_SET) {
784 if (offset < 0) return -1L;
786 /* At this point, offset is the number of zero bytes to write. */
787 if (s->inbuf == Z_NULL) {
788 s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
789 if (s->inbuf == Z_NULL) return -1L;
790 zmemzero(s->inbuf, Z_BUFSIZE);
793 uInt size = Z_BUFSIZE;
794 if (offset < Z_BUFSIZE) size = (uInt)offset;
796 size = gzwrite(file, s->inbuf, size);
797 if (size == 0) return -1L;
804 /* Rest of function is for reading only */
806 /* compute absolute position */
807 if (whence == SEEK_CUR) {
810 if (offset < 0) return -1L;
812 if (s->transparent) {
815 s->stream.avail_in = 0;
816 s->stream.next_in = s->inbuf;
817 if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
819 s->in = s->out = offset;
823 /* For a negative seek, rewind and use positive seek */
824 if (offset >= s->out) {
826 } else if (gzrewind(file) < 0) {
829 /* offset is now the number of bytes to skip. */
831 if (offset != 0 && s->outbuf == Z_NULL) {
832 s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
833 if (s->outbuf == Z_NULL) return -1L;
835 if (offset && s->back != EOF) {
839 if (s->last) s->z_err = Z_STREAM_END;
842 int size = Z_BUFSIZE;
843 if (offset < Z_BUFSIZE) size = (int)offset;
845 size = gzread(file, s->outbuf, (uInt)size);
846 if (size <= 0) return -1L;
852 /* ===========================================================================
855 int ZEXPORT gzrewind (file)
858 gz_stream *s = (gz_stream*)file;
860 if (s == NULL || s->mode != 'r') return -1;
865 s->stream.avail_in = 0;
866 s->stream.next_in = s->inbuf;
867 s->crc = crc32(0L, Z_NULL, 0);
868 if (!s->transparent) (void)inflateReset(&s->stream);
871 return fseek(s->file, s->start, SEEK_SET);
874 /* ===========================================================================
875 Returns the starting position for the next gzread or gzwrite on the
876 given compressed file. This position represents a number of bytes in the
877 uncompressed data stream.
879 z_off_t ZEXPORT gztell (file)
882 return gzseek(file, 0L, SEEK_CUR);
885 /* ===========================================================================
886 Returns 1 when EOF has previously been detected reading the given
887 input stream, otherwise zero.
889 int ZEXPORT gzeof (file)
892 gz_stream *s = (gz_stream*)file;
894 /* With concatenated compressed files that can have embedded
895 * crc trailers, z_eof is no longer the only/best indicator of EOF
896 * on a gz_stream. Handle end-of-stream error explicitly here.
898 if (s == NULL || s->mode != 'r') return 0;
899 if (s->z_eof) return 1;
900 return s->z_err == Z_STREAM_END;
903 /* ===========================================================================
904 Outputs a long in LSB order to the given file
906 local void putLong (file, x)
911 for (n = 0; n < 4; n++) {
912 fputc((int)(x & 0xff), file);
917 /* ===========================================================================
918 Reads a long in LSB order from the given gz_stream. Sets z_err in case
921 local uLong getLong (s)
924 uLong x = (uLong)get_byte(s);
927 x += ((uLong)get_byte(s))<<8;
928 x += ((uLong)get_byte(s))<<16;
930 if (c == EOF) s->z_err = Z_DATA_ERROR;
935 /* ===========================================================================
936 Flushes all pending output if necessary, closes the compressed file
937 and deallocates all the (de)compression state.
939 int ZEXPORT gzclose (file)
943 gz_stream *s = (gz_stream*)file;
945 if (s == NULL) return Z_STREAM_ERROR;
947 if (s->mode == 'w') {
949 return Z_STREAM_ERROR;
951 err = do_flush (file, Z_FINISH);
952 if (err != Z_OK) return destroy((gz_stream*)file);
954 putLong (s->file, s->crc);
955 putLong (s->file, (uLong)(s->in & 0xffffffff));
958 return destroy((gz_stream*)file);
961 /* ===========================================================================
962 Returns the error message for the last error which occured on the
963 given compressed file. errnum is set to zlib error number. If an
964 error occured in the file system and not in the compression library,
965 errnum is set to Z_ERRNO and the application may consult errno
966 to get the exact error code.
968 const char * ZEXPORT gzerror (file, errnum)
973 gz_stream *s = (gz_stream*)file;
976 *errnum = Z_STREAM_ERROR;
977 return (const char*)ERR_MSG(Z_STREAM_ERROR);
980 if (*errnum == Z_OK) return (const char*)"";
982 m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
984 if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
987 s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
988 if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);
989 strcpy(s->msg, s->path);
990 strcat(s->msg, ": ");
992 return (const char*)s->msg;
995 /* ===========================================================================
996 Clear the error and end-of-file flags, and do the same for the real file.
998 void ZEXPORT gzclearerr (file)
1001 gz_stream *s = (gz_stream*)file;
1003 if (s == NULL) return;
1004 if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
1007 /* clearerr(s->file); */