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