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