zlib/gzio.c

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