1
/* gzio.c -- IO on .gz files
2
* Copyright (C) 1995-2005 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.5 2005/07/20 20:32:42 wtchang%redhat.com Exp $ */
14
#ifdef NO_DEFLATE /* for compatibility 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)
223
char name[46]; /* allow for up to 128-bit integers */
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 = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
268
if (s->stream.avail_in == 0) {
270
if (ferror(s->file)) s->z_err = Z_ERRNO;
273
s->stream.next_in = s->inbuf;
275
s->stream.avail_in--;
276
return *(s->stream.next_in)++;
279
/* ===========================================================================
280
Check the gzip header of a gz_stream opened for reading. Set the stream
281
mode to transparent if the gzip magic header is not present; set s->err
282
to Z_DATA_ERROR if the magic header is present but the rest of the header
284
IN assertion: the stream s has already been created sucessfully;
285
s->stream.avail_in is zero for the first time, but may be non-zero
286
for concatenated .gz files.
288
local void check_header(s)
291
int method; /* method byte */
292
int flags; /* flags byte */
296
/* Assure two bytes in the buffer so we can peek ahead -- handle case
297
where first byte of header is at the end of the buffer after the last
299
len = s->stream.avail_in;
301
if (len) s->inbuf[0] = s->stream.next_in[0];
303
len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
304
if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
305
s->stream.avail_in += len;
306
s->stream.next_in = s->inbuf;
307
if (s->stream.avail_in < 2) {
308
s->transparent = s->stream.avail_in;
313
/* Peek ahead to check the gzip magic header */
314
if (s->stream.next_in[0] != gz_magic[0] ||
315
s->stream.next_in[1] != gz_magic[1]) {
319
s->stream.avail_in -= 2;
320
s->stream.next_in += 2;
322
/* Check the rest of the gzip header */
323
method = get_byte(s);
325
if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
326
s->z_err = Z_DATA_ERROR;
330
/* Discard time, xflags and OS code: */
331
for (len = 0; len < 6; len++) (void)get_byte(s);
333
if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
334
len = (uInt)get_byte(s);
335
len += ((uInt)get_byte(s))<<8;
336
/* len is garbage if EOF but the loop below will quit anyway */
337
while (len-- != 0 && get_byte(s) != EOF) ;
339
if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
340
while ((c = get_byte(s)) != 0 && c != EOF) ;
342
if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
343
while ((c = get_byte(s)) != 0 && c != EOF) ;
345
if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
346
for (len = 0; len < 2; len++) (void)get_byte(s);
348
s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
351
/* ===========================================================================
352
* Cleanup then free the given gz_stream. Return a zlib error code.
353
Try freeing in the reverse order of allocations.
355
local int destroy (s)
360
if (!s) return Z_STREAM_ERROR;
364
if (s->stream.state != NULL) {
365
if (s->mode == 'w') {
367
err = Z_STREAM_ERROR;
369
err = deflateEnd(&(s->stream));
371
} else if (s->mode == 'r') {
372
err = inflateEnd(&(s->stream));
375
if (s->file != NULL && fclose(s->file)) {
377
if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
381
if (s->z_err < 0) err = s->z_err;
390
/* ===========================================================================
391
Reads the given number of uncompressed bytes from the compressed file.
392
gzread returns the number of bytes actually read (0 for end of file).
394
int ZEXPORT gzread (file, buf, len)
399
gz_stream *s = (gz_stream*)file;
400
Bytef *start = (Bytef*)buf; /* starting point for crc computation */
401
Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */
403
if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
405
if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
406
if (s->z_err == Z_STREAM_END) return 0; /* EOF */
408
next_out = (Byte*)buf;
409
s->stream.next_out = (Bytef*)buf;
410
s->stream.avail_out = len;
412
if (s->stream.avail_out && s->back != EOF) {
413
*next_out++ = s->back;
414
s->stream.next_out++;
415
s->stream.avail_out--;
420
s->z_err = Z_STREAM_END;
425
while (s->stream.avail_out != 0) {
427
if (s->transparent) {
428
/* Copy first the lookahead bytes: */
429
uInt n = s->stream.avail_in;
430
if (n > s->stream.avail_out) n = s->stream.avail_out;
432
zmemcpy(s->stream.next_out, s->stream.next_in, n);
434
s->stream.next_out = next_out;
435
s->stream.next_in += n;
436
s->stream.avail_out -= n;
437
s->stream.avail_in -= n;
439
if (s->stream.avail_out > 0) {
440
s->stream.avail_out -=
441
(uInt)fread(next_out, 1, s->stream.avail_out, s->file);
443
len -= s->stream.avail_out;
446
if (len == 0) s->z_eof = 1;
449
if (s->stream.avail_in == 0 && !s->z_eof) {
452
s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
453
if (s->stream.avail_in == 0) {
455
if (ferror(s->file)) {
460
s->stream.next_in = s->inbuf;
462
s->in += s->stream.avail_in;
463
s->out += s->stream.avail_out;
464
s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
465
s->in -= s->stream.avail_in;
466
s->out -= s->stream.avail_out;
468
if (s->z_err == Z_STREAM_END) {
469
/* Check CRC and original size */
470
s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
471
start = s->stream.next_out;
473
if (getLong(s) != s->crc) {
474
s->z_err = Z_DATA_ERROR;
477
/* The uncompressed length returned by above getlong() may be
478
* different from s->out in case of concatenated .gz files.
479
* Check for such files:
482
if (s->z_err == Z_OK) {
483
inflateReset(&(s->stream));
484
s->crc = crc32(0L, Z_NULL, 0);
488
if (s->z_err != Z_OK || s->z_eof) break;
490
s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
492
if (len == s->stream.avail_out &&
493
(s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
495
return (int)(len - s->stream.avail_out);
499
/* ===========================================================================
500
Reads one byte from the compressed file. gzgetc returns this byte
501
or -1 in case of end of file or error.
503
int ZEXPORT gzgetc(file)
508
return gzread(file, &c, 1) == 1 ? c : -1;
512
/* ===========================================================================
513
Push one byte back onto the stream.
515
int ZEXPORT gzungetc(c, file)
519
gz_stream *s = (gz_stream*)file;
521
if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
524
s->last = (s->z_err == Z_STREAM_END);
525
if (s->last) s->z_err = Z_OK;
531
/* ===========================================================================
532
Reads bytes from the compressed file until len-1 characters are
533
read, or a newline character is read and transferred to buf, or an
534
end-of-file condition is encountered. The string is then terminated
535
with a null character.
536
gzgets returns buf, or Z_NULL in case of error.
538
The current implementation is not optimized at all.
540
char * ZEXPORT gzgets(file, buf, len)
546
if (buf == Z_NULL || len <= 0) return Z_NULL;
548
while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
550
return b == buf && len > 0 ? Z_NULL : b;
554
#ifndef NO_GZCOMPRESS
555
/* ===========================================================================
556
Writes the given number of uncompressed bytes into the compressed file.
557
gzwrite returns the number of bytes actually written (0 in case of error).
559
int ZEXPORT gzwrite (file, buf, len)
564
gz_stream *s = (gz_stream*)file;
566
if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
568
s->stream.next_in = (Bytef*)buf;
569
s->stream.avail_in = len;
571
while (s->stream.avail_in != 0) {
573
if (s->stream.avail_out == 0) {
575
s->stream.next_out = s->outbuf;
576
if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
580
s->stream.avail_out = Z_BUFSIZE;
582
s->in += s->stream.avail_in;
583
s->out += s->stream.avail_out;
584
s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
585
s->in -= s->stream.avail_in;
586
s->out -= s->stream.avail_out;
587
if (s->z_err != Z_OK) break;
589
s->crc = crc32(s->crc, (const Bytef *)buf, len);
591
return (int)(len - s->stream.avail_in);
595
/* ===========================================================================
596
Converts, formats, and writes the args to the compressed file under
597
control of the format string, as in fprintf. gzprintf returns the number of
598
uncompressed bytes actually written (0 in case of error).
603
int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
605
char buf[Z_PRINTF_BUFSIZE];
609
buf[sizeof(buf) - 1] = 0;
610
va_start(va, format);
612
# ifdef HAS_vsprintf_void
613
(void)vsprintf(buf, format, va);
615
for (len = 0; len < sizeof(buf); len++)
616
if (buf[len] == 0) break;
618
len = vsprintf(buf, format, va);
622
# ifdef HAS_vsnprintf_void
623
(void)vsnprintf(buf, sizeof(buf), format, va);
627
len = vsnprintf(buf, sizeof(buf), format, va);
631
if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
633
return gzwrite(file, buf, (unsigned)len);
635
#else /* not ANSI C */
637
int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
638
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
641
int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
642
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
644
char buf[Z_PRINTF_BUFSIZE];
647
buf[sizeof(buf) - 1] = 0;
649
# ifdef HAS_sprintf_void
650
sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
651
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
652
for (len = 0; len < sizeof(buf); len++)
653
if (buf[len] == 0) break;
655
len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
656
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
659
# ifdef HAS_snprintf_void
660
snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
661
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
664
len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
665
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
668
if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
670
return gzwrite(file, buf, len);
674
/* ===========================================================================
675
Writes c, converted to an unsigned char, into the compressed file.
676
gzputc returns the value that was written, or -1 in case of error.
678
int ZEXPORT gzputc(file, c)
682
unsigned char cc = (unsigned char) c; /* required for big endian systems */
684
return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
688
/* ===========================================================================
689
Writes the given null-terminated string to the compressed file, excluding
690
the terminating null character.
691
gzputs returns the number of characters written, or -1 in case of error.
693
int ZEXPORT gzputs(file, s)
697
return gzwrite(file, (char*)s, (unsigned)strlen(s));
701
/* ===========================================================================
702
Flushes all pending output into the compressed file. The parameter
703
flush is as in the deflate() function.
705
local int do_flush (file, flush)
711
gz_stream *s = (gz_stream*)file;
713
if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
715
s->stream.avail_in = 0; /* should be zero already anyway */
718
len = Z_BUFSIZE - s->stream.avail_out;
721
if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
725
s->stream.next_out = s->outbuf;
726
s->stream.avail_out = Z_BUFSIZE;
729
s->out += s->stream.avail_out;
730
s->z_err = deflate(&(s->stream), flush);
731
s->out -= s->stream.avail_out;
733
/* Ignore the second of two consecutive flushes: */
734
if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
736
/* deflate has finished flushing only when it hasn't used up
737
* all the available space in the output buffer:
739
done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
741
if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
743
return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
746
int ZEXPORT gzflush (file, flush)
750
gz_stream *s = (gz_stream*)file;
751
int err = do_flush (file, flush);
755
return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
757
#endif /* NO_GZCOMPRESS */
759
/* ===========================================================================
760
Sets the starting position for the next gzread or gzwrite on the given
761
compressed file. The offset represents a number of bytes in the
762
gzseek returns the resulting offset location as measured in bytes from
763
the beginning of the uncompressed stream, or -1 in case of error.
764
SEEK_END is not implemented, returns error.
765
In this version of the library, gzseek can be extremely slow.
767
z_off_t ZEXPORT gzseek (file, offset, whence)
772
gz_stream *s = (gz_stream*)file;
774
if (s == NULL || whence == SEEK_END ||
775
s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
779
if (s->mode == 'w') {
783
if (whence == SEEK_SET) {
786
if (offset < 0) return -1L;
788
/* At this point, offset is the number of zero bytes to write. */
789
if (s->inbuf == Z_NULL) {
790
s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
791
if (s->inbuf == Z_NULL) return -1L;
792
zmemzero(s->inbuf, Z_BUFSIZE);
795
uInt size = Z_BUFSIZE;
796
if (offset < Z_BUFSIZE) size = (uInt)offset;
798
size = gzwrite(file, s->inbuf, size);
799
if (size == 0) return -1L;
806
/* Rest of function is for reading only */
808
/* compute absolute position */
809
if (whence == SEEK_CUR) {
812
if (offset < 0) return -1L;
814
if (s->transparent) {
817
s->stream.avail_in = 0;
818
s->stream.next_in = s->inbuf;
819
if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
821
s->in = s->out = offset;
825
/* For a negative seek, rewind and use positive seek */
826
if (offset >= s->out) {
828
} else if (gzrewind(file) < 0) {
831
/* offset is now the number of bytes to skip. */
833
if (offset != 0 && s->outbuf == Z_NULL) {
834
s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
835
if (s->outbuf == Z_NULL) return -1L;
837
if (offset && s->back != EOF) {
841
if (s->last) s->z_err = Z_STREAM_END;
844
int size = Z_BUFSIZE;
845
if (offset < Z_BUFSIZE) size = (int)offset;
847
size = gzread(file, s->outbuf, (uInt)size);
848
if (size <= 0) return -1L;
854
/* ===========================================================================
857
int ZEXPORT gzrewind (file)
860
gz_stream *s = (gz_stream*)file;
862
if (s == NULL || s->mode != 'r') return -1;
867
s->stream.avail_in = 0;
868
s->stream.next_in = s->inbuf;
869
s->crc = crc32(0L, Z_NULL, 0);
870
if (!s->transparent) (void)inflateReset(&s->stream);
873
return fseek(s->file, s->start, SEEK_SET);
876
/* ===========================================================================
877
Returns the starting position for the next gzread or gzwrite on the
878
given compressed file. This position represents a number of bytes in the
879
uncompressed data stream.
881
z_off_t ZEXPORT gztell (file)
884
return gzseek(file, 0L, SEEK_CUR);
887
/* ===========================================================================
888
Returns 1 when EOF has previously been detected reading the given
889
input stream, otherwise zero.
891
int ZEXPORT gzeof (file)
894
gz_stream *s = (gz_stream*)file;
896
/* With concatenated compressed files that can have embedded
897
* crc trailers, z_eof is no longer the only/best indicator of EOF
898
* on a gz_stream. Handle end-of-stream error explicitly here.
900
if (s == NULL || s->mode != 'r') return 0;
901
if (s->z_eof) return 1;
902
return s->z_err == Z_STREAM_END;
905
/* ===========================================================================
906
Returns 1 if reading and doing so transparently, otherwise zero.
908
int ZEXPORT gzdirect (file)
911
gz_stream *s = (gz_stream*)file;
913
if (s == NULL || s->mode != 'r') return 0;
914
return s->transparent;
917
/* ===========================================================================
918
Outputs a long in LSB order to the given file
920
local void putLong (file, x)
925
for (n = 0; n < 4; n++) {
926
fputc((int)(x & 0xff), file);
931
/* ===========================================================================
932
Reads a long in LSB order from the given gz_stream. Sets z_err in case
935
local uLong getLong (s)
938
uLong x = (uLong)get_byte(s);
941
x += ((uLong)get_byte(s))<<8;
942
x += ((uLong)get_byte(s))<<16;
944
if (c == EOF) s->z_err = Z_DATA_ERROR;
949
/* ===========================================================================
950
Flushes all pending output if necessary, closes the compressed file
951
and deallocates all the (de)compression state.
953
int ZEXPORT gzclose (file)
956
gz_stream *s = (gz_stream*)file;
958
if (s == NULL) return Z_STREAM_ERROR;
960
if (s->mode == 'w') {
962
return Z_STREAM_ERROR;
964
if (do_flush (file, Z_FINISH) != Z_OK)
965
return destroy((gz_stream*)file);
967
putLong (s->file, s->crc);
968
putLong (s->file, (uLong)(s->in & 0xffffffff));
971
return destroy((gz_stream*)file);
975
# define zstrerror(errnum) strerror(errnum)
977
# define zstrerror(errnum) ""
980
/* ===========================================================================
981
Returns the error message for the last error which occurred on the
982
given compressed file. errnum is set to zlib error number. If an
983
error occurred in the file system and not in the compression library,
984
errnum is set to Z_ERRNO and the application may consult errno
985
to get the exact error code.
987
const char * ZEXPORT gzerror (file, errnum)
992
gz_stream *s = (gz_stream*)file;
995
*errnum = Z_STREAM_ERROR;
996
return (const char*)ERR_MSG(Z_STREAM_ERROR);
999
if (*errnum == Z_OK) return (const char*)"";
1001
m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
1003
if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
1006
s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
1007
if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);
1008
strcpy(s->msg, s->path);
1009
strcat(s->msg, ": ");
1011
return (const char*)s->msg;
1014
/* ===========================================================================
1015
Clear the error and end-of-file flags, and do the same for the real file.
1017
void ZEXPORT gzclearerr (file)
1020
gz_stream *s = (gz_stream*)file;
1022
if (s == NULL) return;
1023
if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
added
removed
mozilla/security/nss/cmd/zlib/gzio.c
