src/zlib/gzio.c

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