zlib121/gzio.c
changeset 602 691c1eadb8b7
equal deleted inserted replaced
601:243d61784fb8 602:691c1eadb8b7
       
     1 /* gzio.c -- IO on .gz files
       
     2  * Copyright (C) 1995-2003 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 /* @(#) $Id: gzio.c,v 1.1 2003/12/07 05:29:20 icculus Exp $ */
       
     9 
       
    10 #include <stdio.h>
       
    11 
       
    12 #include "zutil.h"
       
    13 
       
    14 #ifdef NO_DEFLATE       /* for compatiblity 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[20];
       
   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 = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
       
   268         if (s->stream.avail_in == 0) {
       
   269             s->z_eof = 1;
       
   270             if (ferror(s->file)) s->z_err = Z_ERRNO;
       
   271             return EOF;
       
   272         }
       
   273         s->stream.next_in = s->inbuf;
       
   274     }
       
   275     s->stream.avail_in--;
       
   276     return *(s->stream.next_in)++;
       
   277 }
       
   278 
       
   279 /* ===========================================================================
       
   280       Check the gzip header of a gz_stream opened for reading. Set the stream
       
   281     mode to transparent if the gzip magic header is not present; set s->err
       
   282     to Z_DATA_ERROR if the magic header is present but the rest of the header
       
   283     is incorrect.
       
   284     IN assertion: the stream s has already been created sucessfully;
       
   285        s->stream.avail_in is zero for the first time, but may be non-zero
       
   286        for concatenated .gz files.
       
   287 */
       
   288 local void check_header(s)
       
   289     gz_stream *s;
       
   290 {
       
   291     int method; /* method byte */
       
   292     int flags;  /* flags byte */
       
   293     uInt len;
       
   294     int c;
       
   295 
       
   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
       
   298        gzip segment */
       
   299     len = s->stream.avail_in;
       
   300     if (len < 2) {
       
   301         if (len) s->inbuf[0] = s->stream.next_in[0];
       
   302         errno = 0;
       
   303         len = fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
       
   304         if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
       
   305         s->stream.avail_in += len;
       
   306         s->stream.next_in = s->inbuf;
       
   307         if (s->stream.avail_in < 2) {
       
   308             s->transparent = s->stream.avail_in;
       
   309             return;
       
   310         }
       
   311     }
       
   312 
       
   313     /* Peek ahead to check the gzip magic header */
       
   314     if (s->stream.next_in[0] != gz_magic[0] ||
       
   315         s->stream.next_in[1] != gz_magic[1]) {
       
   316         s->transparent = 1;
       
   317         return;
       
   318     }
       
   319     s->stream.avail_in -= 2;
       
   320     s->stream.next_in += 2;
       
   321 
       
   322     /* Check the rest of the gzip header */
       
   323     method = get_byte(s);
       
   324     flags = get_byte(s);
       
   325     if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
       
   326         s->z_err = Z_DATA_ERROR;
       
   327         return;
       
   328     }
       
   329 
       
   330     /* Discard time, xflags and OS code: */
       
   331     for (len = 0; len < 6; len++) (void)get_byte(s);
       
   332 
       
   333     if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
       
   334         len  =  (uInt)get_byte(s);
       
   335         len += ((uInt)get_byte(s))<<8;
       
   336         /* len is garbage if EOF but the loop below will quit anyway */
       
   337         while (len-- != 0 && get_byte(s) != EOF) ;
       
   338     }
       
   339     if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
       
   340         while ((c = get_byte(s)) != 0 && c != EOF) ;
       
   341     }
       
   342     if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
       
   343         while ((c = get_byte(s)) != 0 && c != EOF) ;
       
   344     }
       
   345     if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
       
   346         for (len = 0; len < 2; len++) (void)get_byte(s);
       
   347     }
       
   348     s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
       
   349 }
       
   350 
       
   351  /* ===========================================================================
       
   352  * Cleanup then free the given gz_stream. Return a zlib error code.
       
   353    Try freeing in the reverse order of allocations.
       
   354  */
       
   355 local int destroy (s)
       
   356     gz_stream *s;
       
   357 {
       
   358     int err = Z_OK;
       
   359 
       
   360     if (!s) return Z_STREAM_ERROR;
       
   361 
       
   362     TRYFREE(s->msg);
       
   363 
       
   364     if (s->stream.state != NULL) {
       
   365         if (s->mode == 'w') {
       
   366 #ifdef NO_GZCOMPRESS
       
   367             err = Z_STREAM_ERROR;
       
   368 #else
       
   369             err = deflateEnd(&(s->stream));
       
   370 #endif
       
   371         } else if (s->mode == 'r') {
       
   372             err = inflateEnd(&(s->stream));
       
   373         }
       
   374     }
       
   375     if (s->file != NULL && fclose(s->file)) {
       
   376 #ifdef ESPIPE
       
   377         if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
       
   378 #endif
       
   379             err = Z_ERRNO;
       
   380     }
       
   381     if (s->z_err < 0) err = s->z_err;
       
   382 
       
   383     TRYFREE(s->inbuf);
       
   384     TRYFREE(s->outbuf);
       
   385     TRYFREE(s->path);
       
   386     TRYFREE(s);
       
   387     return err;
       
   388 }
       
   389 
       
   390 /* ===========================================================================
       
   391      Reads the given number of uncompressed bytes from the compressed file.
       
   392    gzread returns the number of bytes actually read (0 for end of file).
       
   393 */
       
   394 int ZEXPORT gzread (file, buf, len)
       
   395     gzFile file;
       
   396     voidp buf;
       
   397     unsigned len;
       
   398 {
       
   399     gz_stream *s = (gz_stream*)file;
       
   400     Bytef *start = (Bytef*)buf; /* starting point for crc computation */
       
   401     Byte  *next_out; /* == stream.next_out but not forced far (for MSDOS) */
       
   402 
       
   403     if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
       
   404 
       
   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 */
       
   407 
       
   408     next_out = (Byte*)buf;
       
   409     s->stream.next_out = (Bytef*)buf;
       
   410     s->stream.avail_out = len;
       
   411 
       
   412     if (s->stream.avail_out && s->back != EOF) {
       
   413         *next_out++ = s->back;
       
   414         s->stream.next_out++;
       
   415         s->stream.avail_out--;
       
   416         s->back = EOF;
       
   417         s->out++;
       
   418         if (s->last) {
       
   419             s->z_err = Z_STREAM_END;
       
   420             return 1;
       
   421         }
       
   422     }
       
   423 
       
   424     while (s->stream.avail_out != 0) {
       
   425 
       
   426         if (s->transparent) {
       
   427             /* Copy first the lookahead bytes: */
       
   428             uInt n = s->stream.avail_in;
       
   429             if (n > s->stream.avail_out) n = s->stream.avail_out;
       
   430             if (n > 0) {
       
   431                 zmemcpy(s->stream.next_out, s->stream.next_in, n);
       
   432                 next_out += n;
       
   433                 s->stream.next_out = next_out;
       
   434                 s->stream.next_in   += n;
       
   435                 s->stream.avail_out -= n;
       
   436                 s->stream.avail_in  -= n;
       
   437             }
       
   438             if (s->stream.avail_out > 0) {
       
   439                 s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out,
       
   440                                              s->file);
       
   441             }
       
   442             len -= s->stream.avail_out;
       
   443             s->in  += len;
       
   444             s->out += len;
       
   445             if (len == 0) s->z_eof = 1;
       
   446             return (int)len;
       
   447         }
       
   448         if (s->stream.avail_in == 0 && !s->z_eof) {
       
   449 
       
   450             errno = 0;
       
   451             s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
       
   452             if (s->stream.avail_in == 0) {
       
   453                 s->z_eof = 1;
       
   454                 if (ferror(s->file)) {
       
   455                     s->z_err = Z_ERRNO;
       
   456                     break;
       
   457                 }
       
   458             }
       
   459             s->stream.next_in = s->inbuf;
       
   460         }
       
   461         s->in += s->stream.avail_in;
       
   462         s->out += s->stream.avail_out;
       
   463         s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
       
   464         s->in -= s->stream.avail_in;
       
   465         s->out -= s->stream.avail_out;
       
   466 
       
   467         if (s->z_err == Z_STREAM_END) {
       
   468             /* Check CRC and original size */
       
   469             s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
       
   470             start = s->stream.next_out;
       
   471 
       
   472             if (getLong(s) != s->crc) {
       
   473                 s->z_err = Z_DATA_ERROR;
       
   474             } else {
       
   475                 (void)getLong(s);
       
   476                 /* The uncompressed length returned by above getlong() may be
       
   477                  * different from s->out in case of concatenated .gz files.
       
   478                  * Check for such files:
       
   479                  */
       
   480                 check_header(s);
       
   481                 if (s->z_err == Z_OK) {
       
   482                     inflateReset(&(s->stream));
       
   483                     s->crc = crc32(0L, Z_NULL, 0);
       
   484                 }
       
   485             }
       
   486         }
       
   487         if (s->z_err != Z_OK || s->z_eof) break;
       
   488     }
       
   489     s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
       
   490 
       
   491     return (int)(len - s->stream.avail_out);
       
   492 }
       
   493 
       
   494 
       
   495 /* ===========================================================================
       
   496       Reads one byte from the compressed file. gzgetc returns this byte
       
   497    or -1 in case of end of file or error.
       
   498 */
       
   499 int ZEXPORT gzgetc(file)
       
   500     gzFile file;
       
   501 {
       
   502     unsigned char c;
       
   503 
       
   504     return gzread(file, &c, 1) == 1 ? c : -1;
       
   505 }
       
   506 
       
   507 
       
   508 /* ===========================================================================
       
   509       Push one byte back onto the stream.
       
   510 */
       
   511 int ZEXPORT gzungetc(c, file)
       
   512     int c;
       
   513     gzFile file;
       
   514 {
       
   515     gz_stream *s = (gz_stream*)file;
       
   516 
       
   517     if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
       
   518     s->back = c;
       
   519     s->out--;
       
   520     s->last = (s->z_err == Z_STREAM_END);
       
   521     if (s->last) s->z_err = Z_OK;
       
   522     s->z_eof = 0;
       
   523     return c;
       
   524 }
       
   525 
       
   526 
       
   527 /* ===========================================================================
       
   528       Reads bytes from the compressed file until len-1 characters are
       
   529    read, or a newline character is read and transferred to buf, or an
       
   530    end-of-file condition is encountered.  The string is then terminated
       
   531    with a null character.
       
   532       gzgets returns buf, or Z_NULL in case of error.
       
   533 
       
   534       The current implementation is not optimized at all.
       
   535 */
       
   536 char * ZEXPORT gzgets(file, buf, len)
       
   537     gzFile file;
       
   538     char *buf;
       
   539     int len;
       
   540 {
       
   541     char *b = buf;
       
   542     if (buf == Z_NULL || len <= 0) return Z_NULL;
       
   543 
       
   544     while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
       
   545     *buf = '\0';
       
   546     return b == buf && len > 0 ? Z_NULL : b;
       
   547 }
       
   548 
       
   549 
       
   550 #ifndef NO_GZCOMPRESS
       
   551 /* ===========================================================================
       
   552      Writes the given number of uncompressed bytes into the compressed file.
       
   553    gzwrite returns the number of bytes actually written (0 in case of error).
       
   554 */
       
   555 int ZEXPORT gzwrite (file, buf, len)
       
   556     gzFile file;
       
   557     voidpc buf;
       
   558     unsigned len;
       
   559 {
       
   560     gz_stream *s = (gz_stream*)file;
       
   561 
       
   562     if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
       
   563 
       
   564     s->stream.next_in = (Bytef*)buf;
       
   565     s->stream.avail_in = len;
       
   566 
       
   567     while (s->stream.avail_in != 0) {
       
   568 
       
   569         if (s->stream.avail_out == 0) {
       
   570 
       
   571             s->stream.next_out = s->outbuf;
       
   572             if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
       
   573                 s->z_err = Z_ERRNO;
       
   574                 break;
       
   575             }
       
   576             s->stream.avail_out = Z_BUFSIZE;
       
   577         }
       
   578         s->in += s->stream.avail_in;
       
   579         s->out += s->stream.avail_out;
       
   580         s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
       
   581         s->in -= s->stream.avail_in;
       
   582         s->out -= s->stream.avail_out;
       
   583         if (s->z_err != Z_OK) break;
       
   584     }
       
   585     s->crc = crc32(s->crc, (const Bytef *)buf, len);
       
   586 
       
   587     return (int)(len - s->stream.avail_in);
       
   588 }
       
   589 
       
   590 
       
   591 /* ===========================================================================
       
   592      Converts, formats, and writes the args to the compressed file under
       
   593    control of the format string, as in fprintf. gzprintf returns the number of
       
   594    uncompressed bytes actually written (0 in case of error).
       
   595 */
       
   596 #ifdef STDC
       
   597 #include <stdarg.h>
       
   598 
       
   599 int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
       
   600 {
       
   601     char buf[Z_PRINTF_BUFSIZE];
       
   602     va_list va;
       
   603     int len;
       
   604 
       
   605     buf[sizeof(buf) - 1] = 0;
       
   606     va_start(va, format);
       
   607 #ifdef NO_vsnprintf
       
   608 #  ifdef HAS_vsprintf_void
       
   609     (void)vsprintf(buf, format, va);
       
   610     va_end(va);
       
   611     for (len = 0; len < sizeof(buf); len++)
       
   612         if (buf[len] == 0) break;
       
   613 #  else
       
   614     len = vsprintf(buf, format, va);
       
   615     va_end(va);
       
   616 #  endif
       
   617 #else
       
   618 #  ifdef HAS_vsnprintf_void
       
   619     (void)vsnprintf(buf, sizeof(buf), format, va);
       
   620     va_end(va);
       
   621     len = strlen(buf);
       
   622 #  else
       
   623     len = vsnprintf(buf, sizeof(buf), format, va);
       
   624     va_end(va);
       
   625 #  endif
       
   626 #endif
       
   627     if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
       
   628         return 0;
       
   629     return gzwrite(file, buf, (unsigned)len);
       
   630 }
       
   631 #else /* not ANSI C */
       
   632 
       
   633 int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
       
   634                        a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
       
   635     gzFile file;
       
   636     const char *format;
       
   637     int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
       
   638         a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
       
   639 {
       
   640     char buf[Z_PRINTF_BUFSIZE];
       
   641     int len;
       
   642 
       
   643     buf[sizeof(buf) - 1] = 0;
       
   644 #ifdef NO_snprintf
       
   645 #  ifdef HAS_sprintf_void
       
   646     sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
       
   647             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
       
   648     for (len = 0; len < sizeof(buf); len++)
       
   649         if (buf[len] == 0) break;
       
   650 #  else
       
   651     len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
       
   652                 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
       
   653 #  endif
       
   654 #else
       
   655 #  ifdef HAS_snprintf_void
       
   656     snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
       
   657              a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
       
   658     len = strlen(buf);
       
   659 #  else
       
   660     len = 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);
       
   662 #  endif
       
   663 #endif
       
   664     if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
       
   665         return 0;
       
   666     return gzwrite(file, buf, len);
       
   667 }
       
   668 #endif
       
   669 
       
   670 /* ===========================================================================
       
   671       Writes c, converted to an unsigned char, into the compressed file.
       
   672    gzputc returns the value that was written, or -1 in case of error.
       
   673 */
       
   674 int ZEXPORT gzputc(file, c)
       
   675     gzFile file;
       
   676     int c;
       
   677 {
       
   678     unsigned char cc = (unsigned char) c; /* required for big endian systems */
       
   679 
       
   680     return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
       
   681 }
       
   682 
       
   683 
       
   684 /* ===========================================================================
       
   685       Writes the given null-terminated string to the compressed file, excluding
       
   686    the terminating null character.
       
   687       gzputs returns the number of characters written, or -1 in case of error.
       
   688 */
       
   689 int ZEXPORT gzputs(file, s)
       
   690     gzFile file;
       
   691     const char *s;
       
   692 {
       
   693     return gzwrite(file, (char*)s, (unsigned)strlen(s));
       
   694 }
       
   695 
       
   696 
       
   697 /* ===========================================================================
       
   698      Flushes all pending output into the compressed file. The parameter
       
   699    flush is as in the deflate() function.
       
   700 */
       
   701 local int do_flush (file, flush)
       
   702     gzFile file;
       
   703     int flush;
       
   704 {
       
   705     uInt len;
       
   706     int done = 0;
       
   707     gz_stream *s = (gz_stream*)file;
       
   708 
       
   709     if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
       
   710 
       
   711     s->stream.avail_in = 0; /* should be zero already anyway */
       
   712 
       
   713     for (;;) {
       
   714         len = Z_BUFSIZE - s->stream.avail_out;
       
   715 
       
   716         if (len != 0) {
       
   717             if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
       
   718                 s->z_err = Z_ERRNO;
       
   719                 return Z_ERRNO;
       
   720             }
       
   721             s->stream.next_out = s->outbuf;
       
   722             s->stream.avail_out = Z_BUFSIZE;
       
   723         }
       
   724         if (done) break;
       
   725         s->out += s->stream.avail_out;
       
   726         s->z_err = deflate(&(s->stream), flush);
       
   727         s->out -= s->stream.avail_out;
       
   728 
       
   729         /* Ignore the second of two consecutive flushes: */
       
   730         if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
       
   731 
       
   732         /* deflate has finished flushing only when it hasn't used up
       
   733          * all the available space in the output buffer:
       
   734          */
       
   735         done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
       
   736 
       
   737         if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
       
   738     }
       
   739     return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
       
   740 }
       
   741 
       
   742 int ZEXPORT gzflush (file, flush)
       
   743      gzFile file;
       
   744      int flush;
       
   745 {
       
   746     gz_stream *s = (gz_stream*)file;
       
   747     int err = do_flush (file, flush);
       
   748 
       
   749     if (err) return err;
       
   750     fflush(s->file);
       
   751     return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
       
   752 }
       
   753 #endif /* NO_GZCOMPRESS */
       
   754 
       
   755 /* ===========================================================================
       
   756       Sets the starting position for the next gzread or gzwrite on the given
       
   757    compressed file. The offset represents a number of bytes in the
       
   758       gzseek returns the resulting offset location as measured in bytes from
       
   759    the beginning of the uncompressed stream, or -1 in case of error.
       
   760       SEEK_END is not implemented, returns error.
       
   761       In this version of the library, gzseek can be extremely slow.
       
   762 */
       
   763 z_off_t ZEXPORT gzseek (file, offset, whence)
       
   764     gzFile file;
       
   765     z_off_t offset;
       
   766     int whence;
       
   767 {
       
   768     gz_stream *s = (gz_stream*)file;
       
   769 
       
   770     if (s == NULL || whence == SEEK_END ||
       
   771         s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
       
   772         return -1L;
       
   773     }
       
   774 
       
   775     if (s->mode == 'w') {
       
   776 #ifdef NO_GZCOMPRESS
       
   777         return -1L;
       
   778 #else
       
   779         if (whence == SEEK_SET) {
       
   780             offset -= s->in;
       
   781         }
       
   782         if (offset < 0) return -1L;
       
   783 
       
   784         /* At this point, offset is the number of zero bytes to write. */
       
   785         if (s->inbuf == Z_NULL) {
       
   786             s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
       
   787             if (s->inbuf == Z_NULL) return -1L;
       
   788             zmemzero(s->inbuf, Z_BUFSIZE);
       
   789         }
       
   790         while (offset > 0)  {
       
   791             uInt size = Z_BUFSIZE;
       
   792             if (offset < Z_BUFSIZE) size = (uInt)offset;
       
   793 
       
   794             size = gzwrite(file, s->inbuf, size);
       
   795             if (size == 0) return -1L;
       
   796 
       
   797             offset -= size;
       
   798         }
       
   799         return s->in;
       
   800 #endif
       
   801     }
       
   802     /* Rest of function is for reading only */
       
   803 
       
   804     /* compute absolute position */
       
   805     if (whence == SEEK_CUR) {
       
   806         offset += s->out;
       
   807     }
       
   808     if (offset < 0) return -1L;
       
   809 
       
   810     if (s->transparent) {
       
   811         /* map to fseek */
       
   812         s->back = EOF;
       
   813         s->stream.avail_in = 0;
       
   814         s->stream.next_in = s->inbuf;
       
   815         if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
       
   816 
       
   817         s->in = s->out = offset;
       
   818         return offset;
       
   819     }
       
   820 
       
   821     /* For a negative seek, rewind and use positive seek */
       
   822     if (offset >= s->out) {
       
   823         offset -= s->out;
       
   824     } else if (gzrewind(file) < 0) {
       
   825         return -1L;
       
   826     }
       
   827     /* offset is now the number of bytes to skip. */
       
   828 
       
   829     if (offset != 0 && s->outbuf == Z_NULL) {
       
   830         s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
       
   831         if (s->outbuf == Z_NULL) return -1L;
       
   832     }
       
   833     if (offset && s->back != EOF) {
       
   834         s->back = EOF;
       
   835         s->out++;
       
   836         offset--;
       
   837         if (s->last) s->z_err = Z_STREAM_END;
       
   838     }
       
   839     while (offset > 0)  {
       
   840         int size = Z_BUFSIZE;
       
   841         if (offset < Z_BUFSIZE) size = (int)offset;
       
   842 
       
   843         size = gzread(file, s->outbuf, (uInt)size);
       
   844         if (size <= 0) return -1L;
       
   845         offset -= size;
       
   846     }
       
   847     return s->out;
       
   848 }
       
   849 
       
   850 /* ===========================================================================
       
   851      Rewinds input file.
       
   852 */
       
   853 int ZEXPORT gzrewind (file)
       
   854     gzFile file;
       
   855 {
       
   856     gz_stream *s = (gz_stream*)file;
       
   857 
       
   858     if (s == NULL || s->mode != 'r') return -1;
       
   859 
       
   860     s->z_err = Z_OK;
       
   861     s->z_eof = 0;
       
   862     s->back = EOF;
       
   863     s->stream.avail_in = 0;
       
   864     s->stream.next_in = s->inbuf;
       
   865     s->crc = crc32(0L, Z_NULL, 0);
       
   866     if (!s->transparent) (void)inflateReset(&s->stream);
       
   867     s->in = 0;
       
   868     s->out = 0;
       
   869     return fseek(s->file, s->start, SEEK_SET);
       
   870 }
       
   871 
       
   872 /* ===========================================================================
       
   873      Returns the starting position for the next gzread or gzwrite on the
       
   874    given compressed file. This position represents a number of bytes in the
       
   875    uncompressed data stream.
       
   876 */
       
   877 z_off_t ZEXPORT gztell (file)
       
   878     gzFile file;
       
   879 {
       
   880     return gzseek(file, 0L, SEEK_CUR);
       
   881 }
       
   882 
       
   883 /* ===========================================================================
       
   884      Returns 1 when EOF has previously been detected reading the given
       
   885    input stream, otherwise zero.
       
   886 */
       
   887 int ZEXPORT gzeof (file)
       
   888     gzFile file;
       
   889 {
       
   890     gz_stream *s = (gz_stream*)file;
       
   891 
       
   892     /* With concatenated compressed files that can have embedded
       
   893      * crc trailers, z_eof is no longer the only/best indicator of EOF
       
   894      * on a gz_stream. Handle end-of-stream error explicitly here.
       
   895      */
       
   896     if (s == NULL || s->mode != 'r') return 0;
       
   897     if (s->z_eof) return 1;
       
   898     return s->z_err == Z_STREAM_END;
       
   899 }
       
   900 
       
   901 /* ===========================================================================
       
   902    Outputs a long in LSB order to the given file
       
   903 */
       
   904 local void putLong (file, x)
       
   905     FILE *file;
       
   906     uLong x;
       
   907 {
       
   908     int n;
       
   909     for (n = 0; n < 4; n++) {
       
   910         fputc((int)(x & 0xff), file);
       
   911         x >>= 8;
       
   912     }
       
   913 }
       
   914 
       
   915 /* ===========================================================================
       
   916    Reads a long in LSB order from the given gz_stream. Sets z_err in case
       
   917    of error.
       
   918 */
       
   919 local uLong getLong (s)
       
   920     gz_stream *s;
       
   921 {
       
   922     uLong x = (uLong)get_byte(s);
       
   923     int c;
       
   924 
       
   925     x += ((uLong)get_byte(s))<<8;
       
   926     x += ((uLong)get_byte(s))<<16;
       
   927     c = get_byte(s);
       
   928     if (c == EOF) s->z_err = Z_DATA_ERROR;
       
   929     x += ((uLong)c)<<24;
       
   930     return x;
       
   931 }
       
   932 
       
   933 /* ===========================================================================
       
   934      Flushes all pending output if necessary, closes the compressed file
       
   935    and deallocates all the (de)compression state.
       
   936 */
       
   937 int ZEXPORT gzclose (file)
       
   938     gzFile file;
       
   939 {
       
   940     int err;
       
   941     gz_stream *s = (gz_stream*)file;
       
   942 
       
   943     if (s == NULL) return Z_STREAM_ERROR;
       
   944 
       
   945     if (s->mode == 'w') {
       
   946 #ifdef NO_GZCOMPRESS
       
   947         return Z_STREAM_ERROR;
       
   948 #else
       
   949         err = do_flush (file, Z_FINISH);
       
   950         if (err != Z_OK) return destroy((gz_stream*)file);
       
   951 
       
   952         putLong (s->file, s->crc);
       
   953         putLong (s->file, (uLong)(s->in & 0xffffffff));
       
   954 #endif
       
   955     }
       
   956     return destroy((gz_stream*)file);
       
   957 }
       
   958 
       
   959 /* ===========================================================================
       
   960      Returns the error message for the last error which occured on the
       
   961    given compressed file. errnum is set to zlib error number. If an
       
   962    error occured in the file system and not in the compression library,
       
   963    errnum is set to Z_ERRNO and the application may consult errno
       
   964    to get the exact error code.
       
   965 */
       
   966 const char * ZEXPORT gzerror (file, errnum)
       
   967     gzFile file;
       
   968     int *errnum;
       
   969 {
       
   970     char *m;
       
   971     gz_stream *s = (gz_stream*)file;
       
   972 
       
   973     if (s == NULL) {
       
   974         *errnum = Z_STREAM_ERROR;
       
   975         return (const char*)ERR_MSG(Z_STREAM_ERROR);
       
   976     }
       
   977     *errnum = s->z_err;
       
   978     if (*errnum == Z_OK) return (const char*)"";
       
   979 
       
   980     m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
       
   981 
       
   982     if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
       
   983 
       
   984     TRYFREE(s->msg);
       
   985     s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
       
   986     if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);
       
   987     strcpy(s->msg, s->path);
       
   988     strcat(s->msg, ": ");
       
   989     strcat(s->msg, m);
       
   990     return (const char*)s->msg;
       
   991 }
       
   992 
       
   993 /* ===========================================================================
       
   994      Clear the error and end-of-file flags, and do the same for the real file.
       
   995 */
       
   996 void ZEXPORT gzclearerr (file)
       
   997     gzFile file;
       
   998 {
       
   999     gz_stream *s = (gz_stream*)file;
       
  1000 
       
  1001     if (s == NULL) return;
       
  1002     if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
       
  1003     s->z_eof = 0;
       
  1004     clearerr(s->file);
       
  1005 }