1 files changed, 157 insertions, 206 deletions

diff --git a/gzio.c b/gzio.c
index 13c7289..03a4674 100644
--- a/gzio.c
+++ b/gzio.c
@@ -1,5 +1,5 @@
 /* gzio.c -- IO on .gz files
- * Copyright (C) 1995-1996 Jean-loup Gailly.
+ * Copyright (C) 1995 Jean-loup Gailly.
  * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
@@ -16,7 +16,8 @@ struct internal_state {int dummy;}; /* for buggy compilers */
 #define ALLOC(size) malloc(size)
 #define TRYFREE(p) {if (p) free(p);}
 
-static int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
+#define GZ_MAGIC_1 0x1f
+#define GZ_MAGIC_2 0x8b
 
 /* gzip flag byte */
 #define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
@@ -26,6 +27,10 @@ static int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
 #define COMMENT      0x10 /* bit 4 set: file comment present */
 #define RESERVED     0xE0 /* bits 5..7: reserved */
 
+#ifndef SEEK_CUR
+#  define SEEK_CUR 1
+#endif
+
 typedef struct gz_stream {
     z_stream stream;
     int      z_err;   /* error code for last stream operation */
@@ -41,12 +46,40 @@ typedef struct gz_stream {
 } gz_stream;
 
 
-local gzFile gz_open      OF((const char *path, const char *mode, int  fd));
-local int    get_byte     OF((gz_stream *s));
-local void   check_header OF((gz_stream *s));
-local int    destroy      OF((gz_stream *s));
-local void   putLong      OF((FILE *file, uLong x));
-local uLong  getLong      OF((gz_stream *s));
+local int    destroy OF((gz_stream *s));
+local gzFile gz_open OF((char *path, char *mode, int  fd));
+local void   putLong OF((FILE *file, uLong x));
+local uLong  getLong OF((Bytef *buf));
+
+ /* ===========================================================================
+ * Cleanup then free the given gz_stream. Return a zlib error code.
+ */
+local int destroy (s)
+    gz_stream *s;
+{
+    int err = Z_OK;
+
+    if (!s) return Z_STREAM_ERROR;
+
+    TRYFREE(s->inbuf);
+    TRYFREE(s->outbuf);
+    TRYFREE(s->path);
+    TRYFREE(s->msg);
+
+    if (s->stream.state != NULL) {
+       if (s->mode == 'w') {
+           err = deflateEnd(&(s->stream));
+       } else if (s->mode == 'r') {
+           err = inflateEnd(&(s->stream));
+       }
+    }
+    if (s->file != NULL && fclose(s->file)) {
+        err = Z_ERRNO;
+    }
+    if (s->z_err < 0) err = s->z_err;
+    TRYFREE(s);
+    return err;
+}
 
 /* ===========================================================================
      Opens a gzip (.gz) file for reading or writing. The mode parameter
@@ -58,20 +91,15 @@ local uLong  getLong      OF((gz_stream *s));
    zlib error is Z_MEM_ERROR).
 */
 local gzFile gz_open (path, mode, fd)
-    const char *path;
-    const char *mode;
+    char *path;
+    char *mode;
     int  fd;
 {
     int err;
     int level = Z_DEFAULT_COMPRESSION; /* compression level */
-    char *p = (char*)mode;
-    gz_stream *s;
-    char fmode[80]; /* copy of mode, without the compression level */
-    char *m = fmode;
-
-    if (!path || !mode) return Z_NULL;
+    char *p = mode;
+    gz_stream *s = (gz_stream *)ALLOC(sizeof(gz_stream));
 
-    s = (gz_stream *)ALLOC(sizeof(gz_stream));
     if (!s) return Z_NULL;
 
     s->stream.zalloc = (alloc_func)0;
@@ -96,13 +124,9 @@ local gzFile gz_open (path, mode, fd)
     s->mode = '\0';
     do {
         if (*p == 'r') s->mode = 'r';
-        if (*p == 'w' || *p == 'a') s->mode = 'w';
-        if (*p >= '0' && *p <= '9') {
-            level = *p - '0';
-        } else {
-            *m++ = *p; /* copy the mode */
-        }
-    } while (*p++ && m != fmode + sizeof(fmode));
+        if (*p == 'w') s->mode = 'w';
+        if (*p >= '1' && *p <= '9') level = *p - '0';
+    } while (*p++);
     if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
     
     if (s->mode == 'w') {
@@ -126,7 +150,7 @@ local gzFile gz_open (path, mode, fd)
     s->stream.avail_out = Z_BUFSIZE;
 
     errno = 0;
-    s->file = fd < 0 ? FOPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
+    s->file = fd < 0 ? FOPEN(path, mode) : (FILE*)fdopen(fd, mode);
 
     if (s->file == NULL) {
         return destroy(s), (gzFile)Z_NULL;
@@ -134,10 +158,50 @@ local gzFile gz_open (path, mode, fd)
     if (s->mode == 'w') {
         /* Write a very simple .gz header:
          */
-        fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
+        fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2,
              Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
     } else {
-        check_header(s); /* skip the .gz header */
+        /* Check and skip the header:
+         */
+        Byte c1 = 0, c2 = 0;
+        Byte method = 0;
+        Byte flags = 0;
+        Byte xflags = 0;
+        Byte time[4];
+        Byte osCode;
+        int c;
+
+        s->stream.avail_in = fread(s->inbuf, 1, 2, s->file);
+        if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1
+            || s->inbuf[1] != GZ_MAGIC_2) {
+            s->transparent = 1;
+            return (gzFile)s;
+        }
+        s->stream.avail_in = 0;
+        fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode);
+
+        if (method != Z_DEFLATED || feof(s->file) || (flags & RESERVED) != 0) {
+            s->z_err = Z_DATA_ERROR;
+            return (gzFile)s;
+        }
+        if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
+            long len;
+            fscanf(s->file, "%c%c", &c1, &c2);
+            len = c1 + ((long)c2<<8);
+            fseek(s->file, len, SEEK_CUR);
+        }
+        if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
+            while ((c = getc(s->file)) != 0 && c != EOF) ;
+        }
+        if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
+            while ((c = getc(s->file)) != 0 && c != EOF) ;
+        }
+        if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
+            fscanf(s->file, "%c%c", &c1, &c2);
+        }
+        if (feof(s->file)) {
+            s->z_err = Z_DATA_ERROR;
+        }
     }
     return (gzFile)s;
 }
@@ -146,139 +210,26 @@ local gzFile gz_open (path, mode, fd)
      Opens a gzip (.gz) file for reading or writing.
 */
 gzFile gzopen (path, mode)
-    const char *path;
-    const char *mode;
+    char *path;
+    char *mode;
 {
     return gz_open (path, mode, -1);
 }
 
 /* ===========================================================================
-     Associate a gzFile with the file descriptor fd. fd is not dup'ed here
-   to mimic the behavio(u)r of fdopen.
+     Associate a gzFile with the file descriptor fd.
 */
 gzFile gzdopen (fd, mode)
     int fd;
-    const char *mode;
+    char *mode;
 {
     char name[20];
-
-    if (fd < 0) return (gzFile)Z_NULL;
     sprintf(name, "<fd:%d>", fd); /* for debugging */
 
     return gz_open (name, mode, fd);
 }
 
 /* ===========================================================================
-     Read a byte from a gz_stream; update next_in and avail_in. Return EOF
-   for end of file.
-   IN assertion: the stream s has been sucessfully opened for reading.
-*/
-local int get_byte(s)
-    gz_stream *s;
-{
-    if (s->z_eof) return EOF;
-    if (s->stream.avail_in == 0) {
-        errno = 0;
-        s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
-        if (s->stream.avail_in == 0) {
-            s->z_eof = 1;
-            if (ferror(s->file)) s->z_err = Z_ERRNO;
-            return EOF;
-        }
-        s->stream.next_in = s->inbuf;
-    }
-    s->stream.avail_in--;
-    return *(s->stream.next_in)++;
-}
-
-/* ===========================================================================
-      Check the gzip header of a gz_stream opened for reading. Set the stream
-    mode to transparent if the gzip magic header is not present; set s->err
-    to Z_DATA_ERROR if the magic header is present but the rest of the header
-    is incorrect.
-    IN assertion: the stream s has already been created sucessfully;
-       s->stream.avail_in is zero for the first time, but may be non-zero
-       for concatenated .gz files.
-*/
-local void check_header(s)
-    gz_stream *s;
-{
-    int method = 0;
-    int flags = 0;
-    uInt len;
-    int c;
-
-    /* Check the gzip magic header */
-    for (len = 0; len < 2; len++) {
-        c = get_byte(s);
-        if (c != gz_magic[len]) {
-            s->transparent = 1;
-            if (c != EOF) s->stream.avail_in++, s->stream.next_in--;
-            s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
-            return;
-        }
-    }
-    method = get_byte(s);
-    flags = get_byte(s);
-    if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
-        s->z_err = Z_DATA_ERROR;
-        return;
-    }
-
-    /* Discard time, xflags and OS code: */
-    for (len = 0; len < 6; len++) (void)get_byte(s);
-
-    if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
-        len  =  (uInt)get_byte(s);
-        len += ((uInt)get_byte(s))<<8;
-        /* len is garbage if EOF but the loop below will quit anyway */
-        while (len-- != 0 && get_byte(s) != EOF) ;
-    }
-    if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
-        while ((c = get_byte(s)) != 0 && c != EOF) ;
-    }
-    if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
-        while ((c = get_byte(s)) != 0 && c != EOF) ;
-    }
-    if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
-        for (len = 0; len < 2; len++) (void)get_byte(s);
-    }
-    s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
-}
-
- /* ===========================================================================
- * Cleanup then free the given gz_stream. Return a zlib error code.
-   Try freeing in the reverse order of allocations.
- */
-local int destroy (s)
-    gz_stream *s;
-{
-    int err = Z_OK;
-
-    if (!s) return Z_STREAM_ERROR;
-
-    TRYFREE(s->msg);
-
-    if (s->stream.state != NULL) {
-       if (s->mode == 'w') {
-           err = deflateEnd(&(s->stream));
-       } else if (s->mode == 'r') {
-           err = inflateEnd(&(s->stream));
-       }
-    }
-    if (s->file != NULL && fclose(s->file)) {
-        err = Z_ERRNO;
-    }
-    if (s->z_err < 0) err = s->z_err;
-
-    TRYFREE(s->inbuf);
-    TRYFREE(s->outbuf);
-    TRYFREE(s->path);
-    TRYFREE(s);
-    return err;
-}
-
-/* ===========================================================================
      Reads the given number of uncompressed bytes from the compressed file.
    gzread returns the number of bytes actually read (0 for end of file).
 */
@@ -288,71 +239,52 @@ int gzread (file, buf, len)
     unsigned len;
 {
     gz_stream *s = (gz_stream*)file;
-    Byte *start = buf; /* starting point for crc computation */
 
     if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
 
-    if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
-    if (s->z_err == Z_STREAM_END) return 0;  /* EOF */
+    if (s->transparent) {
+        int n = 0;
+        Byte *b = (Byte*)buf;
+        /* Copy the first two (non-magic) bytes if not done already */
+        while (s->stream.avail_in > 0 && len > 0) {
+            *b++ = *s->stream.next_in++;
+            s->stream.avail_in--;
+            len--; n++;
+        }
+        if (len == 0) return n;
+        return n + fread(b, 1, len, s->file);
+    }
+    if (s->z_err == Z_DATA_ERROR) return -1; /* bad .gz file */
+    if (s->z_err == Z_STREAM_END) return 0;  /* don't read crc as data */
 
     s->stream.next_out = buf;
     s->stream.avail_out = len;
 
     while (s->stream.avail_out != 0) {
 
-        if (s->transparent) {
-            /* Copy first the lookahead bytes: */
-            uInt n = s->stream.avail_in;
-            if (n > s->stream.avail_out) n = s->stream.avail_out;
-            if (n > 0) {
-                zmemcpy(s->stream.next_out, s->stream.next_in, n);
-                s->stream.next_out  += n;
-                s->stream.next_in   += n;
-                s->stream.avail_out -= n;
-                s->stream.avail_in  -= n;
-            }
-            if (s->stream.avail_out > 0) {
-                s->stream.avail_out -= fread(s->stream.next_out,
-                                             1, s->stream.avail_out, s->file);
-            }
-            return (int)(len - s->stream.avail_out);
-        }
         if (s->stream.avail_in == 0 && !s->z_eof) {
 
             errno = 0;
-            s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+            s->stream.avail_in =
+                fread(s->inbuf, 1, Z_BUFSIZE, s->file);
             if (s->stream.avail_in == 0) {
                 s->z_eof = 1;
-                if (ferror(s->file)) {
-                    s->z_err = Z_ERRNO;
-                    break;
-                }
+            } else if (s->stream.avail_in == (uInt)EOF) {
+                s->stream.avail_in = 0;
+                s->z_eof = 1;
+                s->z_err = Z_ERRNO;
+                break;
             }
             s->stream.next_in = s->inbuf;
         }
         s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
 
-        if (s->z_err == Z_STREAM_END) {
-            /* Check CRC and original size */
-            s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
-            start = s->stream.next_out;
-
-            if (getLong(s) != s->crc || getLong(s) != s->stream.total_out) {
-                s->z_err = Z_DATA_ERROR;
-            } else {
-                /* Check for concatenated .gz files: */
-                check_header(s);
-                if (s->z_err == Z_OK) {
-                    inflateReset(&(s->stream));
-                    s->crc = crc32(0L, Z_NULL, 0);
-                }
-            }
-        }
-        if (s->z_err != Z_OK || s->z_eof) break;
+        if (s->z_err == Z_STREAM_END ||
+            s->z_err != Z_OK  || s->z_eof) break;
     }
-    s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
-
-    return (int)(len - s->stream.avail_out);
+    len -= s->stream.avail_out;
+    s->crc = crc32(s->crc, buf, len);
+    return (int)len;
 }
 
 /* ===========================================================================
@@ -361,7 +293,7 @@ int gzread (file, buf, len)
 */
 int gzwrite (file, buf, len)
     gzFile file;
-    const voidp buf;
+    voidp buf;
     unsigned len;
 {
     gz_stream *s = (gz_stream*)file;
@@ -412,7 +344,7 @@ int gzflush (file, flush)
         len = Z_BUFSIZE - s->stream.avail_out;
 
         if (len != 0) {
-            if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
+            if (fwrite(s->outbuf, 1, len, s->file) != len) {
                 s->z_err = Z_ERRNO;
                 return Z_ERRNO;
             }
@@ -448,19 +380,18 @@ local void putLong (file, x)
 }
 
 /* ===========================================================================
-   Reads a long in LSB order from the given gz_stream. Sets 
+   Reads a long in LSB order from the given buffer
 */
-local uLong getLong (s)
-    gz_stream *s;
+local uLong getLong (buf)
+    Bytef *buf;
 {
-    uLong x = (uLong)get_byte(s);
-    int c;
-
-    x += ((uLong)get_byte(s))<<8;
-    x += ((uLong)get_byte(s))<<16;
-    c = get_byte(s);
-    if (c == EOF) s->z_err = Z_DATA_ERROR;
-    x += ((uLong)c)<<24;
+    uLong x = 0;
+    Bytef *p = buf+4;
+
+    do {
+        x <<= 8;
+        x |= *--p; 
+    } while (p != buf);
     return x;
 }
 
@@ -471,6 +402,7 @@ local uLong getLong (s)
 int gzclose (file)
     gzFile file;
 {
+    uInt n;
     int err;
     gz_stream *s = (gz_stream*)file;
 
@@ -483,6 +415,25 @@ int gzclose (file)
         putLong (s->file, s->crc);
         putLong (s->file, s->stream.total_in);
 
+    } else if (s->mode == 'r' && s->z_err == Z_STREAM_END) {
+
+        /* slide CRC and original size if they are at the end of inbuf */
+        if ((n = s->stream.avail_in) < 8  && !s->z_eof) {
+            Byte *p = s->inbuf;
+            Bytef *q = s->stream.next_in;
+            while (n--) { *p++ = *q++; };
+
+            n = s->stream.avail_in;
+            n += fread(p, 1, 8, s->file);
+            s->stream.next_in = s->inbuf;
+        }
+        /* check CRC and original size */
+        if (n < 8 ||
+            getLong(s->stream.next_in) != s->crc ||
+            getLong(s->stream.next_in + 4) != s->stream.total_out) {
+
+            s->z_err = Z_DATA_ERROR;
+        }
     }
     return destroy(file);
 }
@@ -503,14 +454,14 @@ char*  gzerror (file, errnum)
 
     if (s == NULL) {
         *errnum = Z_STREAM_ERROR;
-        return ERR_MSG(Z_STREAM_ERROR);
+        return z_errmsg[1-Z_STREAM_ERROR];
     }
     *errnum = s->z_err;
-    if (*errnum == Z_OK) return (char*)"";
+    if (*errnum == Z_OK) return "";
 
-    m =  (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
+    m =  *errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg;
 
-    if (m == NULL || *m == '\0') m = (char*)z_errmsg[1-s->z_err];
+    if (m == NULL || *m == '\0') m = z_errmsg[1-s->z_err];
 
     TRYFREE(s->msg);
     s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);