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