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