gzio.c 24.5 KB
Newer Older
M
Mark Adler 已提交
1
/* gzio.c -- IO on .gz files
M
Mark Adler 已提交
2
 * Copyright (C) 1995-1998 Jean-loup Gailly.
M
Mark Adler 已提交
3
 * For conditions of distribution and use, see copyright notice in zlib.h
M
Mark Adler 已提交
4 5
 *
 * Compile this file with -DNO_DEFLATE to avoid the compression code.
M
Mark Adler 已提交
6 7
 */

M
Mark Adler 已提交
8
/* @(#) $Id$ */
M
Mark Adler 已提交
9 10 11 12 13 14 15

#include <stdio.h>

#include "zutil.h"

struct internal_state {int dummy;}; /* for buggy compilers */

M
Mark Adler 已提交
16 17
#define Z_BUFSIZE       16384
#define Z_PRINTF_BUFSIZE 4096
M
Mark Adler 已提交
18

M
Mark Adler 已提交
19 20
#define ALLOC(size) malloc(size)
#define TRYFREE(p) {if (p) free(p);}
M
Mark Adler 已提交
21

M
Mark Adler 已提交
22
static int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
M
Mark Adler 已提交
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

/* gzip flag byte */
#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
#define HEAD_CRC     0x02 /* bit 1 set: header CRC present */
#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
#define COMMENT      0x10 /* bit 4 set: file comment present */
#define RESERVED     0xE0 /* bits 5..7: reserved */

typedef struct gz_stream {
    z_stream stream;
    int      z_err;   /* error code for last stream operation */
    int      z_eof;   /* set if end of input file */
    FILE     *file;   /* .gz file */
    Byte     *inbuf;  /* input buffer */
    Byte     *outbuf; /* output buffer */
    uLong    crc;     /* crc32 of uncompressed data */
    char     *msg;    /* error message */
    char     *path;   /* path name for debugging only */
    int      transparent; /* 1 if input file is not a .gz file */
    char     mode;    /* 'w' or 'r' */
M
Mark Adler 已提交
44
    long     startpos; /* start of compressed data in file (header skipped) */
M
Mark Adler 已提交
45 46 47
} gz_stream;


M
Mark Adler 已提交
48
local gzFile gz_open      OF((const char *path, const char *mode, int  fd));
M
Mark Adler 已提交
49
local int do_flush        OF((gzFile file, int flush));
M
Mark Adler 已提交
50 51 52 53 54
local int    get_byte     OF((gz_stream *s));
local void   check_header OF((gz_stream *s));
local int    destroy      OF((gz_stream *s));
local void   putLong      OF((FILE *file, uLong x));
local uLong  getLong      OF((gz_stream *s));
M
Mark Adler 已提交
55 56 57

/* ===========================================================================
     Opens a gzip (.gz) file for reading or writing. The mode parameter
M
Mark Adler 已提交
58
   is as in fopen ("rb" or "wb"). The file is given either by file descriptor
M
Mark Adler 已提交
59 60 61 62 63 64 65
   or path name (if fd == -1).
     gz_open return NULL if the file could not be opened or if there was
   insufficient memory to allocate the (de)compression state; errno
   can be checked to distinguish the two cases (if errno is zero, the
   zlib error is Z_MEM_ERROR).
*/
local gzFile gz_open (path, mode, fd)
M
Mark Adler 已提交
66 67
    const char *path;
    const char *mode;
M
Mark Adler 已提交
68 69 70
    int  fd;
{
    int err;
M
Mark Adler 已提交
71
    int level = Z_DEFAULT_COMPRESSION; /* compression level */
M
Mark Adler 已提交
72
    int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
M
Mark Adler 已提交
73 74 75 76 77 78
    char *p = (char*)mode;
    gz_stream *s;
    char fmode[80]; /* copy of mode, without the compression level */
    char *m = fmode;

    if (!path || !mode) return Z_NULL;
M
Mark Adler 已提交
79

M
Mark Adler 已提交
80
    s = (gz_stream *)ALLOC(sizeof(gz_stream));
M
Mark Adler 已提交
81 82 83 84
    if (!s) return Z_NULL;

    s->stream.zalloc = (alloc_func)0;
    s->stream.zfree = (free_func)0;
M
Mark Adler 已提交
85
    s->stream.opaque = (voidpf)0;
M
Mark Adler 已提交
86 87 88 89 90 91 92 93 94 95 96 97
    s->stream.next_in = s->inbuf = Z_NULL;
    s->stream.next_out = s->outbuf = Z_NULL;
    s->stream.avail_in = s->stream.avail_out = 0;
    s->file = NULL;
    s->z_err = Z_OK;
    s->z_eof = 0;
    s->crc = crc32(0L, Z_NULL, 0);
    s->msg = NULL;
    s->transparent = 0;

    s->path = (char*)ALLOC(strlen(path)+1);
    if (s->path == NULL) {
M
Mark Adler 已提交
98
        return destroy(s), (gzFile)Z_NULL;
M
Mark Adler 已提交
99 100 101 102 103
    }
    strcpy(s->path, path); /* do this early for debugging */

    s->mode = '\0';
    do {
M
Mark Adler 已提交
104
        if (*p == 'r') s->mode = 'r';
M
Mark Adler 已提交
105 106 107
        if (*p == 'w' || *p == 'a') s->mode = 'w';
        if (*p >= '0' && *p <= '9') {
	    level = *p - '0';
M
Mark Adler 已提交
108 109 110 111
	} else if (*p == 'f') {
	  strategy = Z_FILTERED;
	} else if (*p == 'h') {
	  strategy = Z_HUFFMAN_ONLY;
M
Mark Adler 已提交
112 113 114 115
	} else {
	    *m++ = *p; /* copy the mode */
	}
    } while (*p++ && m != fmode + sizeof(fmode));
M
Mark Adler 已提交
116 117 118
    if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
    
    if (s->mode == 'w') {
M
Mark Adler 已提交
119 120 121
#ifdef NO_DEFLATE
        err = Z_STREAM_ERROR;
#else
M
Mark Adler 已提交
122
        err = deflateInit2(&(s->stream), level,
M
Mark Adler 已提交
123
                           Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
M
Mark Adler 已提交
124
        /* windowBits is passed < 0 to suppress zlib header */
M
Mark Adler 已提交
125

M
Mark Adler 已提交
126
        s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
M
Mark Adler 已提交
127
#endif
M
Mark Adler 已提交
128 129 130
        if (err != Z_OK || s->outbuf == Z_NULL) {
            return destroy(s), (gzFile)Z_NULL;
        }
M
Mark Adler 已提交
131
    } else {
M
Mark Adler 已提交
132
        s->stream.next_in  = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
M
Mark Adler 已提交
133

M
Mark Adler 已提交
134 135 136
        err = inflateInit2(&(s->stream), -MAX_WBITS);
        /* windowBits is passed < 0 to tell that there is no zlib header */

M
Mark Adler 已提交
137 138 139
        if (err != Z_OK || s->inbuf == Z_NULL) {
            return destroy(s), (gzFile)Z_NULL;
        }
M
Mark Adler 已提交
140 141 142 143
    }
    s->stream.avail_out = Z_BUFSIZE;

    errno = 0;
M
Mark Adler 已提交
144
    s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
M
Mark Adler 已提交
145 146

    if (s->file == NULL) {
M
Mark Adler 已提交
147
        return destroy(s), (gzFile)Z_NULL;
M
Mark Adler 已提交
148 149
    }
    if (s->mode == 'w') {
M
Mark Adler 已提交
150 151
        /* Write a very simple .gz header:
         */
M
Mark Adler 已提交
152
        fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
M
Mark Adler 已提交
153
             Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
M
Mark Adler 已提交
154 155 156 157 158 159
	s->startpos = 10L;
	/* We use 10L instead of ftell(s->file) to because ftell causes an
         * fflush on some systems. This version of the library doesn't use
         * startpos anyway in write mode, so this initialization is not
         * necessary.
         */
M
Mark Adler 已提交
160
    } else {
M
Mark Adler 已提交
161
	check_header(s); /* skip the .gz header */
M
Mark Adler 已提交
162
	s->startpos = (ftell(s->file) - s->stream.avail_in);
M
Mark Adler 已提交
163
    }
M
Mark Adler 已提交
164
    
M
Mark Adler 已提交
165 166 167 168 169 170
    return (gzFile)s;
}

/* ===========================================================================
     Opens a gzip (.gz) file for reading or writing.
*/
M
Mark Adler 已提交
171
gzFile ZEXPORT gzopen (path, mode)
M
Mark Adler 已提交
172 173
    const char *path;
    const char *mode;
M
Mark Adler 已提交
174 175 176 177 178
{
    return gz_open (path, mode, -1);
}

/* ===========================================================================
M
Mark Adler 已提交
179 180
     Associate a gzFile with the file descriptor fd. fd is not dup'ed here
   to mimic the behavio(u)r of fdopen.
M
Mark Adler 已提交
181
*/
M
Mark Adler 已提交
182
gzFile ZEXPORT gzdopen (fd, mode)
M
Mark Adler 已提交
183
    int fd;
M
Mark Adler 已提交
184
    const char *mode;
M
Mark Adler 已提交
185 186
{
    char name[20];
M
Mark Adler 已提交
187 188

    if (fd < 0) return (gzFile)Z_NULL;
M
Mark Adler 已提交
189
    sprintf(name, "<fd:%d>", fd); /* for debugging */
M
Mark Adler 已提交
190 191 192 193

    return gz_open (name, mode, fd);
}

M
Mark Adler 已提交
194 195 196
/* ===========================================================================
 * Update the compression level and strategy
 */
M
Mark Adler 已提交
197
int ZEXPORT gzsetparams (file, level, strategy)
M
Mark Adler 已提交
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
    gzFile file;
    int level;
    int strategy;
{
    gz_stream *s = (gz_stream*)file;

    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;

    /* Make room to allow flushing */
    if (s->stream.avail_out == 0) {

	s->stream.next_out = s->outbuf;
	if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
	    s->z_err = Z_ERRNO;
	}
	s->stream.avail_out = Z_BUFSIZE;
    }

    return deflateParams (&(s->stream), level, strategy);
}

M
Mark Adler 已提交
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
/* ===========================================================================
     Read a byte from a gz_stream; update next_in and avail_in. Return EOF
   for end of file.
   IN assertion: the stream s has been sucessfully opened for reading.
*/
local int get_byte(s)
    gz_stream *s;
{
    if (s->z_eof) return EOF;
    if (s->stream.avail_in == 0) {
	errno = 0;
	s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
	if (s->stream.avail_in == 0) {
	    s->z_eof = 1;
	    if (ferror(s->file)) s->z_err = Z_ERRNO;
	    return EOF;
	}
	s->stream.next_in = s->inbuf;
    }
    s->stream.avail_in--;
    return *(s->stream.next_in)++;
}

/* ===========================================================================
      Check the gzip header of a gz_stream opened for reading. Set the stream
    mode to transparent if the gzip magic header is not present; set s->err
    to Z_DATA_ERROR if the magic header is present but the rest of the header
    is incorrect.
    IN assertion: the stream s has already been created sucessfully;
       s->stream.avail_in is zero for the first time, but may be non-zero
       for concatenated .gz files.
*/
local void check_header(s)
    gz_stream *s;
{
    int method; /* method byte */
    int flags;  /* flags byte */
    uInt len;
    int c;

    /* Check the gzip magic header */
    for (len = 0; len < 2; len++) {
	c = get_byte(s);
	if (c != gz_magic[len]) {
M
Mark Adler 已提交
263 264 265 266 267
	    if (len != 0) s->stream.avail_in++, s->stream.next_in--;
	    if (c != EOF) {
		s->stream.avail_in++, s->stream.next_in--;
		s->transparent = 1;
	    }
M
Mark Adler 已提交
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
	    s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
	    return;
	}
    }
    method = get_byte(s);
    flags = get_byte(s);
    if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
	s->z_err = Z_DATA_ERROR;
	return;
    }

    /* Discard time, xflags and OS code: */
    for (len = 0; len < 6; len++) (void)get_byte(s);

    if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
	len  =  (uInt)get_byte(s);
	len += ((uInt)get_byte(s))<<8;
	/* len is garbage if EOF but the loop below will quit anyway */
	while (len-- != 0 && get_byte(s) != EOF) ;
    }
    if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
	while ((c = get_byte(s)) != 0 && c != EOF) ;
    }
    if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
	while ((c = get_byte(s)) != 0 && c != EOF) ;
    }
    if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
	for (len = 0; len < 2; len++) (void)get_byte(s);
    }
    s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
}

 /* ===========================================================================
 * Cleanup then free the given gz_stream. Return a zlib error code.
   Try freeing in the reverse order of allocations.
 */
local int destroy (s)
    gz_stream *s;
{
    int err = Z_OK;

    if (!s) return Z_STREAM_ERROR;

    TRYFREE(s->msg);

    if (s->stream.state != NULL) {
M
Mark Adler 已提交
314 315 316 317 318 319 320 321 322
	if (s->mode == 'w') {
#ifdef NO_DEFLATE
	    err = Z_STREAM_ERROR;
#else
	    err = deflateEnd(&(s->stream));
#endif
	} else if (s->mode == 'r') {
	    err = inflateEnd(&(s->stream));
	}
M
Mark Adler 已提交
323 324
    }
    if (s->file != NULL && fclose(s->file)) {
M
Mark Adler 已提交
325 326 327 328
#ifdef ESPIPE
	if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
#endif
	    err = Z_ERRNO;
M
Mark Adler 已提交
329 330 331 332 333 334 335 336 337 338
    }
    if (s->z_err < 0) err = s->z_err;

    TRYFREE(s->inbuf);
    TRYFREE(s->outbuf);
    TRYFREE(s->path);
    TRYFREE(s);
    return err;
}

M
Mark Adler 已提交
339 340 341 342
/* ===========================================================================
     Reads the given number of uncompressed bytes from the compressed file.
   gzread returns the number of bytes actually read (0 for end of file).
*/
M
Mark Adler 已提交
343
int ZEXPORT gzread (file, buf, len)
M
Mark Adler 已提交
344
    gzFile file;
M
Mark Adler 已提交
345
    voidp buf;
M
Mark Adler 已提交
346 347 348
    unsigned len;
{
    gz_stream *s = (gz_stream*)file;
M
Mark Adler 已提交
349
    Bytef *start = (Bytef*)buf; /* starting point for crc computation */
M
Mark Adler 已提交
350
    Byte  *next_out; /* == stream.next_out but not forced far (for MSDOS) */
M
Mark Adler 已提交
351 352 353

    if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;

M
Mark Adler 已提交
354 355
    if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
    if (s->z_err == Z_STREAM_END) return 0;  /* EOF */
M
Mark Adler 已提交
356

M
Mark Adler 已提交
357 358
    next_out = (Byte*)buf;
    s->stream.next_out = (Bytef*)buf;
M
Mark Adler 已提交
359 360 361 362
    s->stream.avail_out = len;

    while (s->stream.avail_out != 0) {

M
Mark Adler 已提交
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
	if (s->transparent) {
	    /* Copy first the lookahead bytes: */
	    uInt n = s->stream.avail_in;
	    if (n > s->stream.avail_out) n = s->stream.avail_out;
	    if (n > 0) {
		zmemcpy(s->stream.next_out, s->stream.next_in, n);
		next_out += n;
		s->stream.next_out = next_out;
		s->stream.next_in   += n;
		s->stream.avail_out -= n;
		s->stream.avail_in  -= n;
	    }
	    if (s->stream.avail_out > 0) {
		s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out,
					     s->file);
	    }
M
Mark Adler 已提交
379 380 381 382
	    len -= s->stream.avail_out;
	    s->stream.total_in  += (uLong)len;
	    s->stream.total_out += (uLong)len;
	    return (int)len;
M
Mark Adler 已提交
383
	}
M
Mark Adler 已提交
384 385 386
        if (s->stream.avail_in == 0 && !s->z_eof) {

            errno = 0;
M
Mark Adler 已提交
387
            s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
M
Mark Adler 已提交
388 389
            if (s->stream.avail_in == 0) {
                s->z_eof = 1;
M
Mark Adler 已提交
390 391 392 393
		if (ferror(s->file)) {
		    s->z_err = Z_ERRNO;
		    break;
		}
M
Mark Adler 已提交
394 395 396 397 398
            }
            s->stream.next_in = s->inbuf;
        }
        s->z_err = inflate(&(s->stream), Z_NO_FLUSH);

M
Mark Adler 已提交
399 400 401 402 403 404 405 406 407 408 409
	if (s->z_err == Z_STREAM_END) {
	    /* Check CRC and original size */
	    s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
	    start = s->stream.next_out;

	    if (getLong(s) != s->crc || getLong(s) != s->stream.total_out) {
		s->z_err = Z_DATA_ERROR;
	    } else {
		/* Check for concatenated .gz files: */
		check_header(s);
		if (s->z_err == Z_OK) {
M
Mark Adler 已提交
410 411 412
		    uLong total_in = s->stream.total_in;
		    uLong total_out = s->stream.total_out;

M
Mark Adler 已提交
413
		    inflateReset(&(s->stream));
M
Mark Adler 已提交
414 415
		    s->stream.total_in = total_in;
		    s->stream.total_out = total_out;
M
Mark Adler 已提交
416 417 418 419 420
		    s->crc = crc32(0L, Z_NULL, 0);
		}
	    }
	}
	if (s->z_err != Z_OK || s->z_eof) break;
M
Mark Adler 已提交
421
    }
M
Mark Adler 已提交
422 423 424
    s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));

    return (int)(len - s->stream.avail_out);
M
Mark Adler 已提交
425 426
}

M
Mark Adler 已提交
427 428 429 430 431

/* ===========================================================================
      Reads one byte from the compressed file. gzgetc returns this byte
   or -1 in case of end of file or error.
*/
M
Mark Adler 已提交
432
int ZEXPORT gzgetc(file)
M
Mark Adler 已提交
433 434
    gzFile file;
{
M
Mark Adler 已提交
435
    unsigned char c;
M
Mark Adler 已提交
436 437 438 439 440

    return gzread(file, &c, 1) == 1 ? c : -1;
}


M
Mark Adler 已提交
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
/* ===========================================================================
      Reads bytes from the compressed file until len-1 characters are
   read, or a newline character is read and transferred to buf, or an
   end-of-file condition is encountered.  The string is then terminated
   with a null character.
      gzgets returns buf, or Z_NULL in case of error.

      The current implementation is not optimized at all.
*/
char * ZEXPORT gzgets(file, buf, len)
    gzFile file;
    char *buf;
    int len;
{
    char *b = buf;
    if (buf == Z_NULL || len <= 0) return Z_NULL;

    while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
    *buf = '\0';
    return b == buf && len > 0 ? Z_NULL : b;
}


M
Mark Adler 已提交
464
#ifndef NO_DEFLATE
M
Mark Adler 已提交
465 466 467 468
/* ===========================================================================
     Writes the given number of uncompressed bytes into the compressed file.
   gzwrite returns the number of bytes actually written (0 in case of error).
*/
M
Mark Adler 已提交
469
int ZEXPORT gzwrite (file, buf, len)
M
Mark Adler 已提交
470
    gzFile file;
M
Mark Adler 已提交
471
    const voidp buf;
M
Mark Adler 已提交
472 473 474 475 476 477
    unsigned len;
{
    gz_stream *s = (gz_stream*)file;

    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;

M
Mark Adler 已提交
478
    s->stream.next_in = (Bytef*)buf;
M
Mark Adler 已提交
479 480 481 482
    s->stream.avail_in = len;

    while (s->stream.avail_in != 0) {

M
Mark Adler 已提交
483
        if (s->stream.avail_out == 0) {
M
Mark Adler 已提交
484

M
Mark Adler 已提交
485 486 487 488 489 490 491 492 493
            s->stream.next_out = s->outbuf;
            if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
                s->z_err = Z_ERRNO;
                break;
            }
            s->stream.avail_out = Z_BUFSIZE;
        }
        s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
        if (s->z_err != Z_OK) break;
M
Mark Adler 已提交
494
    }
M
Mark Adler 已提交
495
    s->crc = crc32(s->crc, (const Bytef *)buf, len);
M
Mark Adler 已提交
496

M
Mark Adler 已提交
497
    return (int)(len - s->stream.avail_in);
M
Mark Adler 已提交
498 499
}

M
Mark Adler 已提交
500 501 502 503 504 505 506 507
/* ===========================================================================
     Converts, formats, and writes the args to the compressed file under
   control of the format string, as in fprintf. gzprintf returns the number of
   uncompressed bytes actually written (0 in case of error).
*/
#ifdef STDC
#include <stdarg.h>

M
Mark Adler 已提交
508
int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
M
Mark Adler 已提交
509
{
M
Mark Adler 已提交
510
    char buf[Z_PRINTF_BUFSIZE];
M
Mark Adler 已提交
511 512 513 514 515
    va_list va;
    int len;

    va_start(va, format);
#ifdef HAS_vsnprintf
M
Mark Adler 已提交
516
    (void)vsnprintf(buf, sizeof(buf), format, va);
M
Mark Adler 已提交
517
#else
M
Mark Adler 已提交
518
    (void)vsprintf(buf, format, va);
M
Mark Adler 已提交
519 520
#endif
    va_end(va);
M
Mark Adler 已提交
521
    len = strlen(buf); /* some *sprintf don't return the nb of bytes written */
M
Mark Adler 已提交
522 523 524 525 526 527
    if (len <= 0) return 0;

    return gzwrite(file, buf, (unsigned)len);
}
#else /* not ANSI C */

M
Mark Adler 已提交
528
int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
M
Mark Adler 已提交
529 530 531 532 533 534
	               a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
    gzFile file;
    const char *format;
    int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
	a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
{
M
Mark Adler 已提交
535
    char buf[Z_PRINTF_BUFSIZE];
M
Mark Adler 已提交
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
    int len;

#ifdef HAS_snprintf
    snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
	     a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
#else
    sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
	    a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
#endif
    len = strlen(buf); /* old sprintf doesn't return the nb of bytes written */
    if (len <= 0) return 0;

    return gzwrite(file, buf, len);
}
#endif

/* ===========================================================================
      Writes c, converted to an unsigned char, into the compressed file.
   gzputc returns the value that was written, or -1 in case of error.
*/
M
Mark Adler 已提交
556
int ZEXPORT gzputc(file, c)
M
Mark Adler 已提交
557 558 559
    gzFile file;
    int c;
{
M
Mark Adler 已提交
560 561 562
    unsigned char cc = (unsigned char) c; /* required for big endian systems */

    return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
M
Mark Adler 已提交
563 564 565
}


M
Mark Adler 已提交
566 567 568 569 570 571 572 573 574 575 576 577 578
/* ===========================================================================
      Writes the given null-terminated string to the compressed file, excluding
   the terminating null character.
      gzputs returns the number of characters written, or -1 in case of error.
*/
int ZEXPORT gzputs(file, s)
    gzFile file;
    const char *s;
{
    return gzwrite(file, (const voidp)s, (unsigned)strlen(s));
}


M
Mark Adler 已提交
579 580 581 582
/* ===========================================================================
     Flushes all pending output into the compressed file. The parameter
   flush is as in the deflate() function.
*/
M
Mark Adler 已提交
583
local int do_flush (file, flush)
M
Mark Adler 已提交
584 585 586 587 588 589 590 591 592 593 594 595
    gzFile file;
    int flush;
{
    uInt len;
    int done = 0;
    gz_stream *s = (gz_stream*)file;

    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;

    s->stream.avail_in = 0; /* should be zero already anyway */

    for (;;) {
M
Mark Adler 已提交
596 597 598
        len = Z_BUFSIZE - s->stream.avail_out;

        if (len != 0) {
M
Mark Adler 已提交
599
            if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
M
Mark Adler 已提交
600 601 602 603 604 605 606 607
                s->z_err = Z_ERRNO;
                return Z_ERRNO;
            }
            s->stream.next_out = s->outbuf;
            s->stream.avail_out = Z_BUFSIZE;
        }
        if (done) break;
        s->z_err = deflate(&(s->stream), flush);
M
Mark Adler 已提交
608

M
Mark Adler 已提交
609 610 611
	/* Ignore the second of two consecutive flushes: */
	if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;

M
Mark Adler 已提交
612
        /* deflate has finished flushing only when it hasn't used up
M
Mark Adler 已提交
613 614
         * all the available space in the output buffer: 
         */
M
Mark Adler 已提交
615 616
        done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
 
M
Mark Adler 已提交
617
        if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
M
Mark Adler 已提交
618
    }
M
Mark Adler 已提交
619 620 621
    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
}

M
Mark Adler 已提交
622
int ZEXPORT gzflush (file, flush)
M
Mark Adler 已提交
623 624 625 626 627 628 629
     gzFile file;
     int flush;
{
    gz_stream *s = (gz_stream*)file;
    int err = do_flush (file, flush);

    if (err) return err;
M
Mark Adler 已提交
630
    fflush(s->file);
M
Mark Adler 已提交
631
    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
M
Mark Adler 已提交
632
}
M
Mark Adler 已提交
633 634 635 636 637 638 639 640 641 642
#endif /* NO_DEFLATE */

/* ===========================================================================
      Sets the starting position for the next gzread or gzwrite on the given
   compressed file. The offset represents a number of bytes in the
      gzseek returns the resulting offset location as measured in bytes from
   the beginning of the uncompressed stream, or -1 in case of error.
      SEEK_END is not implemented, returns error.
      In this version of the library, gzseek can be extremely slow.
*/
M
Mark Adler 已提交
643
z_off_t ZEXPORT gzseek (file, offset, whence)
M
Mark Adler 已提交
644 645 646 647 648 649
    gzFile file;
    z_off_t offset;
    int whence;
{
    gz_stream *s = (gz_stream*)file;

M
Mark Adler 已提交
650 651 652 653
    if (s == NULL || whence == SEEK_END ||
	s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
	return -1L;
    }
M
Mark Adler 已提交
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
    
    if (s->mode == 'w') {
#ifdef NO_DEFLATE
	return -1L;
#else
	if (whence == SEEK_SET) {
	    offset -= s->stream.total_out;
	}
	if (offset < 0) return -1L;

	/* At this point, offset is the number of zero bytes to write. */
	if (s->inbuf == Z_NULL) {
	    s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
	    zmemzero(s->inbuf, Z_BUFSIZE);
	}
	while (offset > 0)  {
	    uInt size = Z_BUFSIZE;
	    if (offset < Z_BUFSIZE) size = (uInt)offset;

	    size = gzwrite(file, s->inbuf, size);
	    if (size == 0) return -1L;

	    offset -= size;
	}
M
Mark Adler 已提交
678
	return (z_off_t)s->stream.total_in;
M
Mark Adler 已提交
679 680 681 682 683 684 685 686 687 688 689 690 691 692
#endif
    }
    /* Rest of function is for reading only */

    /* compute absolute position */
    if (whence == SEEK_CUR) {
	offset += s->stream.total_out;
    }
    if (offset < 0) return -1L;

    if (s->transparent) {
	/* map to fseek */
	s->stream.avail_in = 0;
	s->stream.next_in = s->inbuf;
M
Mark Adler 已提交
693 694 695
        if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;

	s->stream.total_in = s->stream.total_out = (uLong)offset;
M
Mark Adler 已提交
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
	return offset;
    }

    /* For a negative seek, rewind and use positive seek */
    if ((uLong)offset >= s->stream.total_out) {
	offset -= s->stream.total_out;
    } else if (gzrewind(file) < 0) {
	return -1L;
    }
    /* offset is now the number of bytes to skip. */

    if (offset != 0 && s->outbuf == Z_NULL) {
	s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
    }
    while (offset > 0)  {
	int size = Z_BUFSIZE;
	if (offset < Z_BUFSIZE) size = (int)offset;

	size = gzread(file, s->outbuf, (uInt)size);
	if (size <= 0) return -1L;
	offset -= size;
    }
M
Mark Adler 已提交
718
    return (z_off_t)s->stream.total_out;
M
Mark Adler 已提交
719 720 721 722 723
}

/* ===========================================================================
     Rewinds input file. 
*/
M
Mark Adler 已提交
724
int ZEXPORT gzrewind (file)
M
Mark Adler 已提交
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749
    gzFile file;
{
    gz_stream *s = (gz_stream*)file;
    
    if (s == NULL || s->mode != 'r') return -1;

    s->z_err = Z_OK;
    s->z_eof = 0;
    s->stream.avail_in = 0;
    s->stream.next_in = s->inbuf;
	
    if (s->startpos == 0) { /* not a compressed file */
	rewind(s->file);
	return 0;
    }

    (void) inflateReset(&s->stream);
    return fseek(s->file, s->startpos, SEEK_SET);
}

/* ===========================================================================
     Returns the starting position for the next gzread or gzwrite on the
   given compressed file. This position represents a number of bytes in the
   uncompressed data stream.
*/
M
Mark Adler 已提交
750
z_off_t ZEXPORT gztell (file)
M
Mark Adler 已提交
751 752 753 754 755 756 757 758 759
    gzFile file;
{
    return gzseek(file, 0L, SEEK_CUR);
}

/* ===========================================================================
     Returns 1 when EOF has previously been detected reading the given
   input stream, otherwise zero.
*/
M
Mark Adler 已提交
760
int ZEXPORT gzeof (file)
M
Mark Adler 已提交
761 762 763 764 765 766
    gzFile file;
{
    gz_stream *s = (gz_stream*)file;
    
    return (s == NULL || s->mode != 'r') ? 0 : s->z_eof;
}
M
Mark Adler 已提交
767 768 769 770 771 772 773 774 775 776

/* ===========================================================================
   Outputs a long in LSB order to the given file
*/
local void putLong (file, x)
    FILE *file;
    uLong x;
{
    int n;
    for (n = 0; n < 4; n++) {
M
Mark Adler 已提交
777 778
        fputc((int)(x & 0xff), file);
        x >>= 8;
M
Mark Adler 已提交
779 780 781 782
    }
}

/* ===========================================================================
M
Mark Adler 已提交
783
   Reads a long in LSB order from the given gz_stream. Sets 
M
Mark Adler 已提交
784
*/
M
Mark Adler 已提交
785 786
local uLong getLong (s)
    gz_stream *s;
M
Mark Adler 已提交
787
{
M
Mark Adler 已提交
788 789 790 791 792 793 794 795
    uLong x = (uLong)get_byte(s);
    int c;

    x += ((uLong)get_byte(s))<<8;
    x += ((uLong)get_byte(s))<<16;
    c = get_byte(s);
    if (c == EOF) s->z_err = Z_DATA_ERROR;
    x += ((uLong)c)<<24;
M
Mark Adler 已提交
796 797 798 799 800 801 802
    return x;
}

/* ===========================================================================
     Flushes all pending output if necessary, closes the compressed file
   and deallocates all the (de)compression state.
*/
M
Mark Adler 已提交
803
int ZEXPORT gzclose (file)
M
Mark Adler 已提交
804 805
    gzFile file;
{
M
Mark Adler 已提交
806
    int err;
M
Mark Adler 已提交
807 808 809 810 811
    gz_stream *s = (gz_stream*)file;

    if (s == NULL) return Z_STREAM_ERROR;

    if (s->mode == 'w') {
M
Mark Adler 已提交
812 813 814 815 816
#ifdef NO_DEFLATE
	return Z_STREAM_ERROR;
#else
        err = do_flush (file, Z_FINISH);
        if (err != Z_OK) return destroy((gz_stream*)file);
M
Mark Adler 已提交
817

M
Mark Adler 已提交
818 819
        putLong (s->file, s->crc);
        putLong (s->file, s->stream.total_in);
M
Mark Adler 已提交
820
#endif
M
Mark Adler 已提交
821
    }
M
Mark Adler 已提交
822
    return destroy((gz_stream*)file);
M
Mark Adler 已提交
823 824 825 826 827 828 829 830 831
}

/* ===========================================================================
     Returns the error message for the last error which occured on the
   given compressed file. errnum is set to zlib error number. If an
   error occured in the file system and not in the compression library,
   errnum is set to Z_ERRNO and the application may consult errno
   to get the exact error code.
*/
M
Mark Adler 已提交
832
const char*  ZEXPORT gzerror (file, errnum)
M
Mark Adler 已提交
833 834 835 836 837 838 839
    gzFile file;
    int *errnum;
{
    char *m;
    gz_stream *s = (gz_stream*)file;

    if (s == NULL) {
M
Mark Adler 已提交
840
        *errnum = Z_STREAM_ERROR;
M
Mark Adler 已提交
841
        return (const char*)ERR_MSG(Z_STREAM_ERROR);
M
Mark Adler 已提交
842 843
    }
    *errnum = s->z_err;
M
Mark Adler 已提交
844
    if (*errnum == Z_OK) return (const char*)"";
M
Mark Adler 已提交
845

M
Mark Adler 已提交
846
    m =  (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
M
Mark Adler 已提交
847

M
Mark Adler 已提交
848
    if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
M
Mark Adler 已提交
849 850 851 852 853 854

    TRYFREE(s->msg);
    s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
    strcpy(s->msg, s->path);
    strcat(s->msg, ": ");
    strcat(s->msg, m);
M
Mark Adler 已提交
855
    return (const char*)s->msg;
M
Mark Adler 已提交
856
}