com32/lib/zlib/gzio.c

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