1 /* $NetBSD: zlib.h,v 1.1 2014/03/09 00:15:45 agc Exp $ */ 2 3 /* zlib.h -- interface of the 'zlib' general purpose compression library 4 version 1.2.3, July 18th, 2005 5 6 Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler 7 8 This software is provided 'as-is', without any express or implied 9 warranty. In no event will the authors be held liable for any damages 10 arising from the use of this software. 11 12 Permission is granted to anyone to use this software for any purpose, 13 including commercial applications, and to alter it and redistribute it 14 freely, subject to the following restrictions: 15 16 1. The origin of this software must not be misrepresented; you must not 17 claim that you wrote the original software. If you use this software 18 in a product, an acknowledgment in the product documentation would be 19 appreciated but is not required. 20 2. Altered source versions must be plainly marked as such, and must not be 21 misrepresented as being the original software. 22 3. This notice may not be removed or altered from any source distribution. 23 24 Jean-loup Gailly Mark Adler 25 jloup@gzip.org madler@alumni.caltech.edu 26 27 28 The data format used by the zlib library is described by RFCs (Request for 29 Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt 30 (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). 31 */ 32 33 #ifndef ZLIB_H 34 #define ZLIB_H 35 36 #include "config.h" 37 38 /* $NetBSD: zlib.h,v 1.1 2014/03/09 00:15:45 agc Exp $ */ 39 40 /* zconf.h -- configuration of the zlib compression library 41 * Copyright (C) 1995-2005 Jean-loup Gailly. 42 * For conditions of distribution and use, see copyright notice in zlib.h 43 */ 44 45 /* @(#) Id */ 46 47 #ifndef ZCONF_H 48 #define ZCONF_H 49 50 #include <sys/types.h> 51 52 /* 53 * If you *really* need a unique prefix for all types and library functions, 54 * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. 55 */ 56 #ifdef Z_PREFIX 57 # define deflateInit_ z_deflateInit_ 58 # define deflate z_deflate 59 # define deflateEnd z_deflateEnd 60 # define inflateInit_ z_inflateInit_ 61 # define inflate z_inflate 62 # define inflateEnd z_inflateEnd 63 # define deflateInit2_ z_deflateInit2_ 64 # define deflateSetDictionary z_deflateSetDictionary 65 # define deflateCopy z_deflateCopy 66 # define deflateReset z_deflateReset 67 # define deflateParams z_deflateParams 68 # define deflateBound z_deflateBound 69 # define deflatePrime z_deflatePrime 70 # define inflateInit2_ z_inflateInit2_ 71 # define inflateSetDictionary z_inflateSetDictionary 72 # define inflateSync z_inflateSync 73 # define inflateSyncPoint z_inflateSyncPoint 74 # define inflateCopy z_inflateCopy 75 # define inflateReset z_inflateReset 76 # define inflateBack z_inflateBack 77 # define inflateBackEnd z_inflateBackEnd 78 # define compress z_compress 79 # define compress2 z_compress2 80 # define compressBound z_compressBound 81 # define uncompress z_uncompress 82 # define adler32 z_adler32 83 # define crc32 z_crc32 84 # define get_crc_table z_get_crc_table 85 # define zError z_zError 86 87 # define alloc_func z_alloc_func 88 # define free_func z_free_func 89 # define in_func z_in_func 90 # define out_func z_out_func 91 # define Byte z_Byte 92 # define uInt z_uInt 93 # define uLong z_uLong 94 # define Bytef z_Bytef 95 # define charf z_charf 96 # define intf z_intf 97 # define uIntf z_uIntf 98 # define uLongf z_uLongf 99 # define voidpf z_voidpf 100 # define voidp z_voidp 101 #endif 102 103 #if defined(__MSDOS__) && !defined(MSDOS) 104 # define MSDOS 105 #endif 106 #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) 107 # define OS2 108 #endif 109 #if defined(_WINDOWS) && !defined(WINDOWS) 110 # define WINDOWS 111 #endif 112 #if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) 113 # ifndef WIN32 114 # define WIN32 115 # endif 116 #endif 117 #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) 118 # if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) 119 # ifndef SYS16BIT 120 # define SYS16BIT 121 # endif 122 # endif 123 #endif 124 125 /* 126 * Compile with -DMAXSEG_64K if the alloc function cannot allocate more 127 * than 64k bytes at a time (needed on systems with 16-bit int). 128 */ 129 #ifdef SYS16BIT 130 # define MAXSEG_64K 131 #endif 132 #ifdef MSDOS 133 # define UNALIGNED_OK 134 #endif 135 136 #ifdef __STDC_VERSION__ 137 # ifndef STDC 138 # define STDC 139 # endif 140 # if __STDC_VERSION__ >= 199901L 141 # ifndef STDC99 142 # define STDC99 143 # endif 144 # endif 145 #endif 146 #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) 147 # define STDC 148 #endif 149 #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) 150 # define STDC 151 #endif 152 #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) 153 # define STDC 154 #endif 155 #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) 156 # define STDC 157 #endif 158 159 #if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ 160 # define STDC 161 #endif 162 163 #ifndef STDC 164 # ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ 165 # define const /* note: need a more gentle solution here */ 166 # endif 167 #endif 168 169 /* Some Mac compilers merge all .h files incorrectly: */ 170 #if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) 171 # define NO_DUMMY_DECL 172 #endif 173 174 /* Maximum value for memLevel in deflateInit2 */ 175 #ifndef MAX_MEM_LEVEL 176 # ifdef MAXSEG_64K 177 # define MAX_MEM_LEVEL 8 178 # else 179 # define MAX_MEM_LEVEL 9 180 # endif 181 #endif 182 183 /* Maximum value for windowBits in deflateInit2 and inflateInit2. 184 * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files 185 * created by gzip. (Files created by minigzip can still be extracted by 186 * gzip.) 187 */ 188 #ifndef MAX_WBITS 189 # define MAX_WBITS 15 /* 32K LZ77 window */ 190 #endif 191 192 /* The memory requirements for deflate are (in bytes): 193 (1 << (windowBits+2)) + (1 << (memLevel+9)) 194 that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) 195 plus a few kilobytes for small objects. For example, if you want to reduce 196 the default memory requirements from 256K to 128K, compile with 197 make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" 198 Of course this will generally degrade compression (there's no free lunch). 199 200 The memory requirements for inflate are (in bytes) 1 << windowBits 201 that is, 32K for windowBits=15 (default value) plus a few kilobytes 202 for small objects. 203 */ 204 205 /* Type declarations */ 206 207 #ifndef OF /* function prototypes */ 208 # ifdef STDC 209 # define OF(args) args 210 # else 211 # define OF(args) () 212 # endif 213 #endif 214 215 /* The following definitions for FAR are needed only for MSDOS mixed 216 * model programming (small or medium model with some far allocations). 217 * This was tested only with MSC; for other MSDOS compilers you may have 218 * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, 219 * just define FAR to be empty. 220 */ 221 #ifdef SYS16BIT 222 # if defined(M_I86SM) || defined(M_I86MM) 223 /* MSC small or medium model */ 224 # define SMALL_MEDIUM 225 # ifdef _MSC_VER 226 # define FAR _far 227 # else 228 # define FAR far 229 # endif 230 # endif 231 # if (defined(__SMALL__) || defined(__MEDIUM__)) 232 /* Turbo C small or medium model */ 233 # define SMALL_MEDIUM 234 # ifdef __BORLANDC__ 235 # define FAR _far 236 # else 237 # define FAR far 238 # endif 239 # endif 240 #endif 241 242 #if defined(WINDOWS) || defined(WIN32) 243 /* If building or using zlib as a DLL, define ZLIB_DLL. 244 * This is not mandatory, but it offers a little performance increase. 245 */ 246 # ifdef ZLIB_DLL 247 # if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) 248 # ifdef ZLIB_INTERNAL 249 # define ZEXTERN extern __declspec(dllexport) 250 # else 251 # define ZEXTERN extern __declspec(dllimport) 252 # endif 253 # endif 254 # endif /* ZLIB_DLL */ 255 /* If building or using zlib with the WINAPI/WINAPIV calling convention, 256 * define ZLIB_WINAPI. 257 * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. 258 */ 259 # ifdef ZLIB_WINAPI 260 # ifdef FAR 261 # undef FAR 262 # endif 263 # include <windows.h> 264 /* No need for _export, use ZLIB.DEF instead. */ 265 /* For complete Windows compatibility, use WINAPI, not __stdcall. */ 266 # define ZEXPORT WINAPI 267 # ifdef WIN32 268 # define ZEXPORTVA WINAPIV 269 # else 270 # define ZEXPORTVA FAR CDECL 271 # endif 272 # endif 273 #endif 274 275 #if defined (__BEOS__) 276 # ifdef ZLIB_DLL 277 # ifdef ZLIB_INTERNAL 278 # define ZEXPORT __declspec(dllexport) 279 # define ZEXPORTVA __declspec(dllexport) 280 # else 281 # define ZEXPORT __declspec(dllimport) 282 # define ZEXPORTVA __declspec(dllimport) 283 # endif 284 # endif 285 #endif 286 287 #ifndef ZEXTERN 288 # define ZEXTERN extern 289 #endif 290 #ifndef ZEXPORT 291 # define ZEXPORT 292 #endif 293 #ifndef ZEXPORTVA 294 # define ZEXPORTVA 295 #endif 296 297 #ifndef FAR 298 # define FAR 299 #endif 300 301 #if !defined(__MACTYPES__) 302 typedef unsigned char Byte; /* 8 bits */ 303 #endif 304 typedef unsigned int uInt; /* 16 bits or more */ 305 typedef unsigned long uLong; /* 32 bits or more */ 306 307 #ifdef SMALL_MEDIUM 308 /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ 309 # define Bytef Byte FAR 310 #else 311 typedef Byte FAR Bytef; 312 #endif 313 typedef char FAR charf; 314 typedef int FAR intf; 315 typedef uInt FAR uIntf; 316 typedef uLong FAR uLongf; 317 318 #ifdef STDC 319 typedef void const *voidpc; 320 typedef void FAR *voidpf; 321 typedef void *voidp; 322 #else 323 typedef Byte const *voidpc; 324 typedef Byte FAR *voidpf; 325 typedef Byte *voidp; 326 #endif 327 328 #if defined(HAVE_UNISTD_H) || (defined(__NetBSD__) && (!defined(_KERNEL) && !defined(_STANDALONE))) 329 # include <sys/types.h> /* for off_t */ 330 # include <unistd.h> /* for SEEK_* and off_t */ 331 # ifdef VMS 332 # include <unixio.h> /* for off_t */ 333 # endif 334 # define z_off_t off_t 335 # define z_ptrdiff_t ptrdiff_t 336 #endif 337 #ifndef SEEK_SET 338 # define SEEK_SET 0 /* Seek from beginning of file. */ 339 # define SEEK_CUR 1 /* Seek from current position. */ 340 # define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ 341 #endif 342 #ifndef z_off_t 343 # define z_off_t long 344 #endif 345 #ifndef z_ptrdiff_t 346 # define z_ptrdiff_t long 347 #endif 348 349 #if defined(__OS400__) 350 # define NO_vsnprintf 351 #endif 352 353 #if defined(__MVS__) 354 # define NO_vsnprintf 355 # ifdef FAR 356 # undef FAR 357 # endif 358 #endif 359 360 /* MVS linker does not support external names larger than 8 bytes */ 361 #if defined(__MVS__) 362 # pragma map(deflateInit_,"DEIN") 363 # pragma map(deflateInit2_,"DEIN2") 364 # pragma map(deflateEnd,"DEEND") 365 # pragma map(deflateBound,"DEBND") 366 # pragma map(inflateInit_,"ININ") 367 # pragma map(inflateInit2_,"ININ2") 368 # pragma map(inflateEnd,"INEND") 369 # pragma map(inflateSync,"INSY") 370 # pragma map(inflateSetDictionary,"INSEDI") 371 # pragma map(compressBound,"CMBND") 372 # pragma map(inflate_table,"INTABL") 373 # pragma map(inflate_fast,"INFA") 374 # pragma map(inflate_copyright,"INCOPY") 375 #endif 376 377 #endif /* ZCONF_H */ 378 #ifdef __cplusplus 379 extern "C" { 380 #endif 381 382 #define ZLIB_VERSION "1.2.3" 383 #define ZLIB_VERNUM 0x1230 384 385 /* 386 The 'zlib' compression library provides in-memory compression and 387 decompression functions, including integrity checks of the uncompressed 388 data. This version of the library supports only one compression method 389 (deflation) but other algorithms will be added later and will have the same 390 stream interface. 391 392 Compression can be done in a single step if the buffers are large 393 enough (for example if an input file is mmap'ed), or can be done by 394 repeated calls of the compression function. In the latter case, the 395 application must provide more input and/or consume the output 396 (providing more output space) before each call. 397 398 The compressed data format used by default by the in-memory functions is 399 the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped 400 around a deflate stream, which is itself documented in RFC 1951. 401 402 The library also supports reading and writing files in gzip (.gz) format 403 with an interface similar to that of stdio using the functions that start 404 with "gz". The gzip format is different from the zlib format. gzip is a 405 gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. 406 407 This library can optionally read and write gzip streams in memory as well. 408 409 The zlib format was designed to be compact and fast for use in memory 410 and on communications channels. The gzip format was designed for single- 411 file compression on file systems, has a larger header than zlib to maintain 412 directory information, and uses a different, slower check method than zlib. 413 414 The library does not install any signal handler. The decoder checks 415 the consistency of the compressed data, so the library should never 416 crash even in case of corrupted input. 417 */ 418 419 typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); 420 typedef void (*free_func) OF((voidpf opaque, voidpf address)); 421 422 struct internal_state; 423 424 typedef struct z_stream_s { 425 Bytef *next_in; /* next input byte */ 426 uInt avail_in; /* number of bytes available at next_in */ 427 uLong total_in; /* total nb of input bytes read so far */ 428 429 Bytef *next_out; /* next output byte should be put there */ 430 uInt avail_out; /* remaining free space at next_out */ 431 uLong total_out; /* total nb of bytes output so far */ 432 433 char *msg; /* last error message, NULL if no error */ 434 struct internal_state FAR *state; /* not visible by applications */ 435 436 alloc_func zalloc; /* used to allocate the internal state */ 437 free_func zfree; /* used to free the internal state */ 438 voidpf opaque; /* private data object passed to zalloc and zfree */ 439 440 int data_type; /* best guess about the data type: binary or text */ 441 uLong adler; /* adler32 value of the uncompressed data */ 442 uLong reserved; /* reserved for future use */ 443 } z_stream; 444 445 typedef z_stream FAR *z_streamp; 446 447 /* 448 gzip header information passed to and from zlib routines. See RFC 1952 449 for more details on the meanings of these fields. 450 */ 451 typedef struct gz_header_s { 452 int text; /* true if compressed data believed to be text */ 453 uLong time; /* modification time */ 454 int xflags; /* extra flags (not used when writing a gzip file) */ 455 int os; /* operating system */ 456 Bytef *extra; /* pointer to extra field or Z_NULL if none */ 457 uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ 458 uInt extra_max; /* space at extra (only when reading header) */ 459 Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ 460 uInt name_max; /* space at name (only when reading header) */ 461 Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ 462 uInt comm_max; /* space at comment (only when reading header) */ 463 int hcrc; /* true if there was or will be a header crc */ 464 int done; /* true when done reading gzip header (not used 465 when writing a gzip file) */ 466 } gz_header; 467 468 typedef gz_header FAR *gz_headerp; 469 470 /* 471 The application must update next_in and avail_in when avail_in has 472 dropped to zero. It must update next_out and avail_out when avail_out 473 has dropped to zero. The application must initialize zalloc, zfree and 474 opaque before calling the init function. All other fields are set by the 475 compression library and must not be updated by the application. 476 477 The opaque value provided by the application will be passed as the first 478 parameter for calls of zalloc and zfree. This can be useful for custom 479 memory management. The compression library attaches no meaning to the 480 opaque value. 481 482 zalloc must return Z_NULL if there is not enough memory for the object. 483 If zlib is used in a multi-threaded application, zalloc and zfree must be 484 thread safe. 485 486 On 16-bit systems, the functions zalloc and zfree must be able to allocate 487 exactly 65536 bytes, but will not be required to allocate more than this 488 if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, 489 pointers returned by zalloc for objects of exactly 65536 bytes *must* 490 have their offset normalized to zero. The default allocation function 491 provided by this library ensures this (see zutil.c). To reduce memory 492 requirements and avoid any allocation of 64K objects, at the expense of 493 compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). 494 495 The fields total_in and total_out can be used for statistics or 496 progress reports. After compression, total_in holds the total size of 497 the uncompressed data and may be saved for use in the decompressor 498 (particularly if the decompressor wants to decompress everything in 499 a single step). 500 */ 501 502 /* constants */ 503 504 #define Z_NO_FLUSH 0 505 #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ 506 #define Z_SYNC_FLUSH 2 507 #define Z_FULL_FLUSH 3 508 #define Z_FINISH 4 509 #define Z_BLOCK 5 510 /* Allowed flush values; see deflate() and inflate() below for details */ 511 512 #define Z_OK 0 513 #define Z_STREAM_END 1 514 #define Z_NEED_DICT 2 515 #define Z_ERRNO (-1) 516 #define Z_STREAM_ERROR (-2) 517 #define Z_DATA_ERROR (-3) 518 #define Z_MEM_ERROR (-4) 519 #define Z_BUF_ERROR (-5) 520 #define Z_VERSION_ERROR (-6) 521 /* Return codes for the compression/decompression functions. Negative 522 * values are errors, positive values are used for special but normal events. 523 */ 524 525 #define Z_NO_COMPRESSION 0 526 #define Z_BEST_SPEED 1 527 #define Z_BEST_COMPRESSION 9 528 #define Z_DEFAULT_COMPRESSION (-1) 529 /* compression levels */ 530 531 #define Z_FILTERED 1 532 #define Z_HUFFMAN_ONLY 2 533 #define Z_RLE 3 534 #define Z_FIXED 4 535 #define Z_DEFAULT_STRATEGY 0 536 /* compression strategy; see deflateInit2() below for details */ 537 538 #define Z_BINARY 0 539 #define Z_TEXT 1 540 #define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ 541 #define Z_UNKNOWN 2 542 /* Possible values of the data_type field (though see inflate()) */ 543 544 #define Z_DEFLATED 8 545 /* The deflate compression method (the only one supported in this version) */ 546 547 #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ 548 549 #define zlib_version zlibVersion() 550 /* for compatibility with versions < 1.0.2 */ 551 552 /* basic functions */ 553 554 ZEXTERN const char * ZEXPORT zlibVersion OF((void)); 555 /* The application can compare zlibVersion and ZLIB_VERSION for consistency. 556 If the first character differs, the library code actually used is 557 not compatible with the zlib.h header file used by the application. 558 This check is automatically made by deflateInit and inflateInit. 559 */ 560 561 /* 562 ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); 563 564 Initializes the internal stream state for compression. The fields 565 zalloc, zfree and opaque must be initialized before by the caller. 566 If zalloc and zfree are set to Z_NULL, deflateInit updates them to 567 use default allocation functions. 568 569 The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: 570 1 gives best speed, 9 gives best compression, 0 gives no compression at 571 all (the input data is simply copied a block at a time). 572 Z_DEFAULT_COMPRESSION requests a default compromise between speed and 573 compression (currently equivalent to level 6). 574 575 deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not 576 enough memory, Z_STREAM_ERROR if level is not a valid compression level, 577 Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible 578 with the version assumed by the caller (ZLIB_VERSION). 579 msg is set to null if there is no error message. deflateInit does not 580 perform any compression: this will be done by deflate(). 581 */ 582 583 584 ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); 585 /* 586 deflate compresses as much data as possible, and stops when the input 587 buffer becomes empty or the output buffer becomes full. It may introduce some 588 output latency (reading input without producing any output) except when 589 forced to flush. 590 591 The detailed semantics are as follows. deflate performs one or both of the 592 following actions: 593 594 - Compress more input starting at next_in and update next_in and avail_in 595 accordingly. If not all input can be processed (because there is not 596 enough room in the output buffer), next_in and avail_in are updated and 597 processing will resume at this point for the next call of deflate(). 598 599 - Provide more output starting at next_out and update next_out and avail_out 600 accordingly. This action is forced if the parameter flush is non zero. 601 Forcing flush frequently degrades the compression ratio, so this parameter 602 should be set only when necessary (in interactive applications). 603 Some output may be provided even if flush is not set. 604 605 Before the call of deflate(), the application should ensure that at least 606 one of the actions is possible, by providing more input and/or consuming 607 more output, and updating avail_in or avail_out accordingly; avail_out 608 should never be zero before the call. The application can consume the 609 compressed output when it wants, for example when the output buffer is full 610 (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK 611 and with zero avail_out, it must be called again after making room in the 612 output buffer because there might be more output pending. 613 614 Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to 615 decide how much data to accumualte before producing output, in order to 616 maximize compression. 617 618 If the parameter flush is set to Z_SYNC_FLUSH, all pending output is 619 flushed to the output buffer and the output is aligned on a byte boundary, so 620 that the decompressor can get all input data available so far. (In particular 621 avail_in is zero after the call if enough output space has been provided 622 before the call.) Flushing may degrade compression for some compression 623 algorithms and so it should be used only when necessary. 624 625 If flush is set to Z_FULL_FLUSH, all output is flushed as with 626 Z_SYNC_FLUSH, and the compression state is reset so that decompression can 627 restart from this point if previous compressed data has been damaged or if 628 random access is desired. Using Z_FULL_FLUSH too often can seriously degrade 629 compression. 630 631 If deflate returns with avail_out == 0, this function must be called again 632 with the same value of the flush parameter and more output space (updated 633 avail_out), until the flush is complete (deflate returns with non-zero 634 avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that 635 avail_out is greater than six to avoid repeated flush markers due to 636 avail_out == 0 on return. 637 638 If the parameter flush is set to Z_FINISH, pending input is processed, 639 pending output is flushed and deflate returns with Z_STREAM_END if there 640 was enough output space; if deflate returns with Z_OK, this function must be 641 called again with Z_FINISH and more output space (updated avail_out) but no 642 more input data, until it returns with Z_STREAM_END or an error. After 643 deflate has returned Z_STREAM_END, the only possible operations on the 644 stream are deflateReset or deflateEnd. 645 646 Z_FINISH can be used immediately after deflateInit if all the compression 647 is to be done in a single step. In this case, avail_out must be at least 648 the value returned by deflateBound (see below). If deflate does not return 649 Z_STREAM_END, then it must be called again as described above. 650 651 deflate() sets strm->adler to the adler32 checksum of all input read 652 so far (that is, total_in bytes). 653 654 deflate() may update strm->data_type if it can make a good guess about 655 the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered 656 binary. This field is only for information purposes and does not affect 657 the compression algorithm in any manner. 658 659 deflate() returns Z_OK if some progress has been made (more input 660 processed or more output produced), Z_STREAM_END if all input has been 661 consumed and all output has been produced (only when flush is set to 662 Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example 663 if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible 664 (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not 665 fatal, and deflate() can be called again with more input and more output 666 space to continue compressing. 667 */ 668 669 670 ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); 671 /* 672 All dynamically allocated data structures for this stream are freed. 673 This function discards any unprocessed input and does not flush any 674 pending output. 675 676 deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the 677 stream state was inconsistent, Z_DATA_ERROR if the stream was freed 678 prematurely (some input or output was discarded). In the error case, 679 msg may be set but then points to a static string (which must not be 680 deallocated). 681 */ 682 683 684 /* 685 ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); 686 687 Initializes the internal stream state for decompression. The fields 688 next_in, avail_in, zalloc, zfree and opaque must be initialized before by 689 the caller. If next_in is not Z_NULL and avail_in is large enough (the exact 690 value depends on the compression method), inflateInit determines the 691 compression method from the zlib header and allocates all data structures 692 accordingly; otherwise the allocation will be deferred to the first call of 693 inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to 694 use default allocation functions. 695 696 inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough 697 memory, Z_VERSION_ERROR if the zlib library version is incompatible with the 698 version assumed by the caller. msg is set to null if there is no error 699 message. inflateInit does not perform any decompression apart from reading 700 the zlib header if present: this will be done by inflate(). (So next_in and 701 avail_in may be modified, but next_out and avail_out are unchanged.) 702 */ 703 704 705 ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); 706 /* 707 inflate decompresses as much data as possible, and stops when the input 708 buffer becomes empty or the output buffer becomes full. It may introduce 709 some output latency (reading input without producing any output) except when 710 forced to flush. 711 712 The detailed semantics are as follows. inflate performs one or both of the 713 following actions: 714 715 - Decompress more input starting at next_in and update next_in and avail_in 716 accordingly. If not all input can be processed (because there is not 717 enough room in the output buffer), next_in is updated and processing 718 will resume at this point for the next call of inflate(). 719 720 - Provide more output starting at next_out and update next_out and avail_out 721 accordingly. inflate() provides as much output as possible, until there 722 is no more input data or no more space in the output buffer (see below 723 about the flush parameter). 724 725 Before the call of inflate(), the application should ensure that at least 726 one of the actions is possible, by providing more input and/or consuming 727 more output, and updating the next_* and avail_* values accordingly. 728 The application can consume the uncompressed output when it wants, for 729 example when the output buffer is full (avail_out == 0), or after each 730 call of inflate(). If inflate returns Z_OK and with zero avail_out, it 731 must be called again after making room in the output buffer because there 732 might be more output pending. 733 734 The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, 735 Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much 736 output as possible to the output buffer. Z_BLOCK requests that inflate() stop 737 if and when it gets to the next deflate block boundary. When decoding the 738 zlib or gzip format, this will cause inflate() to return immediately after 739 the header and before the first block. When doing a raw inflate, inflate() 740 will go ahead and process the first block, and will return when it gets to 741 the end of that block, or when it runs out of data. 742 743 The Z_BLOCK option assists in appending to or combining deflate streams. 744 Also to assist in this, on return inflate() will set strm->data_type to the 745 number of unused bits in the last byte taken from strm->next_in, plus 64 746 if inflate() is currently decoding the last block in the deflate stream, 747 plus 128 if inflate() returned immediately after decoding an end-of-block 748 code or decoding the complete header up to just before the first byte of the 749 deflate stream. The end-of-block will not be indicated until all of the 750 uncompressed data from that block has been written to strm->next_out. The 751 number of unused bits may in general be greater than seven, except when 752 bit 7 of data_type is set, in which case the number of unused bits will be 753 less than eight. 754 755 inflate() should normally be called until it returns Z_STREAM_END or an 756 error. However if all decompression is to be performed in a single step 757 (a single call of inflate), the parameter flush should be set to 758 Z_FINISH. In this case all pending input is processed and all pending 759 output is flushed; avail_out must be large enough to hold all the 760 uncompressed data. (The size of the uncompressed data may have been saved 761 by the compressor for this purpose.) The next operation on this stream must 762 be inflateEnd to deallocate the decompression state. The use of Z_FINISH 763 is never required, but can be used to inform inflate that a faster approach 764 may be used for the single inflate() call. 765 766 In this implementation, inflate() always flushes as much output as 767 possible to the output buffer, and always uses the faster approach on the 768 first call. So the only effect of the flush parameter in this implementation 769 is on the return value of inflate(), as noted below, or when it returns early 770 because Z_BLOCK is used. 771 772 If a preset dictionary is needed after this call (see inflateSetDictionary 773 below), inflate sets strm->adler to the adler32 checksum of the dictionary 774 chosen by the compressor and returns Z_NEED_DICT; otherwise it sets 775 strm->adler to the adler32 checksum of all output produced so far (that is, 776 total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described 777 below. At the end of the stream, inflate() checks that its computed adler32 778 checksum is equal to that saved by the compressor and returns Z_STREAM_END 779 only if the checksum is correct. 780 781 inflate() will decompress and check either zlib-wrapped or gzip-wrapped 782 deflate data. The header type is detected automatically. Any information 783 contained in the gzip header is not retained, so applications that need that 784 information should instead use raw inflate, see inflateInit2() below, or 785 inflateBack() and perform their own processing of the gzip header and 786 trailer. 787 788 inflate() returns Z_OK if some progress has been made (more input processed 789 or more output produced), Z_STREAM_END if the end of the compressed data has 790 been reached and all uncompressed output has been produced, Z_NEED_DICT if a 791 preset dictionary is needed at this point, Z_DATA_ERROR if the input data was 792 corrupted (input stream not conforming to the zlib format or incorrect check 793 value), Z_STREAM_ERROR if the stream structure was inconsistent (for example 794 if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, 795 Z_BUF_ERROR if no progress is possible or if there was not enough room in the 796 output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and 797 inflate() can be called again with more input and more output space to 798 continue decompressing. If Z_DATA_ERROR is returned, the application may then 799 call inflateSync() to look for a good compression block if a partial recovery 800 of the data is desired. 801 */ 802 803 804 ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); 805 /* 806 All dynamically allocated data structures for this stream are freed. 807 This function discards any unprocessed input and does not flush any 808 pending output. 809 810 inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state 811 was inconsistent. In the error case, msg may be set but then points to a 812 static string (which must not be deallocated). 813 */ 814 815 /* Advanced functions */ 816 817 /* 818 The following functions are needed only in some special applications. 819 */ 820 821 /* 822 ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, 823 int level, 824 int method, 825 int windowBits, 826 int memLevel, 827 int strategy)); 828 829 This is another version of deflateInit with more compression options. The 830 fields next_in, zalloc, zfree and opaque must be initialized before by 831 the caller. 832 833 The method parameter is the compression method. It must be Z_DEFLATED in 834 this version of the library. 835 836 The windowBits parameter is the base two logarithm of the window size 837 (the size of the history buffer). It should be in the range 8..15 for this 838 version of the library. Larger values of this parameter result in better 839 compression at the expense of memory usage. The default value is 15 if 840 deflateInit is used instead. 841 842 windowBits can also be -8..-15 for raw deflate. In this case, -windowBits 843 determines the window size. deflate() will then generate raw deflate data 844 with no zlib header or trailer, and will not compute an adler32 check value. 845 846 windowBits can also be greater than 15 for optional gzip encoding. Add 847 16 to windowBits to write a simple gzip header and trailer around the 848 compressed data instead of a zlib wrapper. The gzip header will have no 849 file name, no extra data, no comment, no modification time (set to zero), 850 no header crc, and the operating system will be set to 255 (unknown). If a 851 gzip stream is being written, strm->adler is a crc32 instead of an adler32. 852 853 The memLevel parameter specifies how much memory should be allocated 854 for the internal compression state. memLevel=1 uses minimum memory but 855 is slow and reduces compression ratio; memLevel=9 uses maximum memory 856 for optimal speed. The default value is 8. See zconf.h for total memory 857 usage as a function of windowBits and memLevel. 858 859 The strategy parameter is used to tune the compression algorithm. Use the 860 value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a 861 filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no 862 string match), or Z_RLE to limit match distances to one (run-length 863 encoding). Filtered data consists mostly of small values with a somewhat 864 random distribution. In this case, the compression algorithm is tuned to 865 compress them better. The effect of Z_FILTERED is to force more Huffman 866 coding and less string matching; it is somewhat intermediate between 867 Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as 868 Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy 869 parameter only affects the compression ratio but not the correctness of the 870 compressed output even if it is not set appropriately. Z_FIXED prevents the 871 use of dynamic Huffman codes, allowing for a simpler decoder for special 872 applications. 873 874 deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 875 memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid 876 method). msg is set to null if there is no error message. deflateInit2 does 877 not perform any compression: this will be done by deflate(). 878 */ 879 880 ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, 881 const Bytef *dictionary, 882 uInt dictLength)); 883 /* 884 Initializes the compression dictionary from the given byte sequence 885 without producing any compressed output. This function must be called 886 immediately after deflateInit, deflateInit2 or deflateReset, before any 887 call of deflate. The compressor and decompressor must use exactly the same 888 dictionary (see inflateSetDictionary). 889 890 The dictionary should consist of strings (byte sequences) that are likely 891 to be encountered later in the data to be compressed, with the most commonly 892 used strings preferably put towards the end of the dictionary. Using a 893 dictionary is most useful when the data to be compressed is short and can be 894 predicted with good accuracy; the data can then be compressed better than 895 with the default empty dictionary. 896 897 Depending on the size of the compression data structures selected by 898 deflateInit or deflateInit2, a part of the dictionary may in effect be 899 discarded, for example if the dictionary is larger than the window size in 900 deflate or deflate2. Thus the strings most likely to be useful should be 901 put at the end of the dictionary, not at the front. In addition, the 902 current implementation of deflate will use at most the window size minus 903 262 bytes of the provided dictionary. 904 905 Upon return of this function, strm->adler is set to the adler32 value 906 of the dictionary; the decompressor may later use this value to determine 907 which dictionary has been used by the compressor. (The adler32 value 908 applies to the whole dictionary even if only a subset of the dictionary is 909 actually used by the compressor.) If a raw deflate was requested, then the 910 adler32 value is not computed and strm->adler is not set. 911 912 deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a 913 parameter is invalid (such as NULL dictionary) or the stream state is 914 inconsistent (for example if deflate has already been called for this stream 915 or if the compression method is bsort). deflateSetDictionary does not 916 perform any compression: this will be done by deflate(). 917 */ 918 919 ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, 920 z_streamp source)); 921 /* 922 Sets the destination stream as a complete copy of the source stream. 923 924 This function can be useful when several compression strategies will be 925 tried, for example when there are several ways of pre-processing the input 926 data with a filter. The streams that will be discarded should then be freed 927 by calling deflateEnd. Note that deflateCopy duplicates the internal 928 compression state which can be quite large, so this strategy is slow and 929 can consume lots of memory. 930 931 deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not 932 enough memory, Z_STREAM_ERROR if the source stream state was inconsistent 933 (such as zalloc being NULL). msg is left unchanged in both source and 934 destination. 935 */ 936 937 ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); 938 /* 939 This function is equivalent to deflateEnd followed by deflateInit, 940 but does not free and reallocate all the internal compression state. 941 The stream will keep the same compression level and any other attributes 942 that may have been set by deflateInit2. 943 944 deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source 945 stream state was inconsistent (such as zalloc or state being NULL). 946 */ 947 948 ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, 949 int level, 950 int strategy)); 951 /* 952 Dynamically update the compression level and compression strategy. The 953 interpretation of level and strategy is as in deflateInit2. This can be 954 used to switch between compression and straight copy of the input data, or 955 to switch to a different kind of input data requiring a different 956 strategy. If the compression level is changed, the input available so far 957 is compressed with the old level (and may be flushed); the new level will 958 take effect only at the next call of deflate(). 959 960 Before the call of deflateParams, the stream state must be set as for 961 a call of deflate(), since the currently available input may have to 962 be compressed and flushed. In particular, strm->avail_out must be non-zero. 963 964 deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source 965 stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR 966 if strm->avail_out was zero. 967 */ 968 969 ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, 970 int good_length, 971 int max_lazy, 972 int nice_length, 973 int max_chain)); 974 /* 975 Fine tune deflate's internal compression parameters. This should only be 976 used by someone who understands the algorithm used by zlib's deflate for 977 searching for the best matching string, and even then only by the most 978 fanatic optimizer trying to squeeze out the last compressed bit for their 979 specific input data. Read the deflate.c source code for the meaning of the 980 max_lazy, good_length, nice_length, and max_chain parameters. 981 982 deflateTune() can be called after deflateInit() or deflateInit2(), and 983 returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. 984 */ 985 986 ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, 987 uLong sourceLen)); 988 /* 989 deflateBound() returns an upper bound on the compressed size after 990 deflation of sourceLen bytes. It must be called after deflateInit() 991 or deflateInit2(). This would be used to allocate an output buffer 992 for deflation in a single pass, and so would be called before deflate(). 993 */ 994 995 ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, 996 int bits, 997 int value)); 998 /* 999 deflatePrime() inserts bits in the deflate output stream. The intent 1000 is that this function is used to start off the deflate output with the 1001 bits leftover from a previous deflate stream when appending to it. As such, 1002 this function can only be used for raw deflate, and must be used before the 1003 first deflate() call after a deflateInit2() or deflateReset(). bits must be 1004 less than or equal to 16, and that many of the least significant bits of 1005 value will be inserted in the output. 1006 1007 deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source 1008 stream state was inconsistent. 1009 */ 1010 1011 ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, 1012 gz_headerp head)); 1013 /* 1014 deflateSetHeader() provides gzip header information for when a gzip 1015 stream is requested by deflateInit2(). deflateSetHeader() may be called 1016 after deflateInit2() or deflateReset() and before the first call of 1017 deflate(). The text, time, os, extra field, name, and comment information 1018 in the provided gz_header structure are written to the gzip header (xflag is 1019 ignored -- the extra flags are set according to the compression level). The 1020 caller must assure that, if not Z_NULL, name and comment are terminated with 1021 a zero byte, and that if extra is not Z_NULL, that extra_len bytes are 1022 available there. If hcrc is true, a gzip header crc is included. Note that 1023 the current versions of the command-line version of gzip (up through version 1024 1.3.x) do not support header crc's, and will report that it is a "multi-part 1025 gzip file" and give up. 1026 1027 If deflateSetHeader is not used, the default gzip header has text false, 1028 the time set to zero, and os set to 255, with no extra, name, or comment 1029 fields. The gzip header is returned to the default state by deflateReset(). 1030 1031 deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source 1032 stream state was inconsistent. 1033 */ 1034 1035 /* 1036 ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, 1037 int windowBits)); 1038 1039 This is another version of inflateInit with an extra parameter. The 1040 fields next_in, avail_in, zalloc, zfree and opaque must be initialized 1041 before by the caller. 1042 1043 The windowBits parameter is the base two logarithm of the maximum window 1044 size (the size of the history buffer). It should be in the range 8..15 for 1045 this version of the library. The default value is 15 if inflateInit is used 1046 instead. windowBits must be greater than or equal to the windowBits value 1047 provided to deflateInit2() while compressing, or it must be equal to 15 if 1048 deflateInit2() was not used. If a compressed stream with a larger window 1049 size is given as input, inflate() will return with the error code 1050 Z_DATA_ERROR instead of trying to allocate a larger window. 1051 1052 windowBits can also be -8..-15 for raw inflate. In this case, -windowBits 1053 determines the window size. inflate() will then process raw deflate data, 1054 not looking for a zlib or gzip header, not generating a check value, and not 1055 looking for any check values for comparison at the end of the stream. This 1056 is for use with other formats that use the deflate compressed data format 1057 such as zip. Those formats provide their own check values. If a custom 1058 format is developed using the raw deflate format for compressed data, it is 1059 recommended that a check value such as an adler32 or a crc32 be applied to 1060 the uncompressed data as is done in the zlib, gzip, and zip formats. For 1061 most applications, the zlib format should be used as is. Note that comments 1062 above on the use in deflateInit2() applies to the magnitude of windowBits. 1063 1064 windowBits can also be greater than 15 for optional gzip decoding. Add 1065 32 to windowBits to enable zlib and gzip decoding with automatic header 1066 detection, or add 16 to decode only the gzip format (the zlib format will 1067 return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is 1068 a crc32 instead of an adler32. 1069 1070 inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 1071 memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg 1072 is set to null if there is no error message. inflateInit2 does not perform 1073 any decompression apart from reading the zlib header if present: this will 1074 be done by inflate(). (So next_in and avail_in may be modified, but next_out 1075 and avail_out are unchanged.) 1076 */ 1077 1078 ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, 1079 const Bytef *dictionary, 1080 uInt dictLength)); 1081 /* 1082 Initializes the decompression dictionary from the given uncompressed byte 1083 sequence. This function must be called immediately after a call of inflate, 1084 if that call returned Z_NEED_DICT. The dictionary chosen by the compressor 1085 can be determined from the adler32 value returned by that call of inflate. 1086 The compressor and decompressor must use exactly the same dictionary (see 1087 deflateSetDictionary). For raw inflate, this function can be called 1088 immediately after inflateInit2() or inflateReset() and before any call of 1089 inflate() to set the dictionary. The application must insure that the 1090 dictionary that was used for compression is provided. 1091 1092 inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a 1093 parameter is invalid (such as NULL dictionary) or the stream state is 1094 inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the 1095 expected one (incorrect adler32 value). inflateSetDictionary does not 1096 perform any decompression: this will be done by subsequent calls of 1097 inflate(). 1098 */ 1099 1100 ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); 1101 /* 1102 Skips invalid compressed data until a full flush point (see above the 1103 description of deflate with Z_FULL_FLUSH) can be found, or until all 1104 available input is skipped. No output is provided. 1105 1106 inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR 1107 if no more input was provided, Z_DATA_ERROR if no flush point has been found, 1108 or Z_STREAM_ERROR if the stream structure was inconsistent. In the success 1109 case, the application may save the current current value of total_in which 1110 indicates where valid compressed data was found. In the error case, the 1111 application may repeatedly call inflateSync, providing more input each time, 1112 until success or end of the input data. 1113 */ 1114 1115 ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, 1116 z_streamp source)); 1117 /* 1118 Sets the destination stream as a complete copy of the source stream. 1119 1120 This function can be useful when randomly accessing a large stream. The 1121 first pass through the stream can periodically record the inflate state, 1122 allowing restarting inflate at those points when randomly accessing the 1123 stream. 1124 1125 inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not 1126 enough memory, Z_STREAM_ERROR if the source stream state was inconsistent 1127 (such as zalloc being NULL). msg is left unchanged in both source and 1128 destination. 1129 */ 1130 1131 ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); 1132 /* 1133 This function is equivalent to inflateEnd followed by inflateInit, 1134 but does not free and reallocate all the internal decompression state. 1135 The stream will keep attributes that may have been set by inflateInit2. 1136 1137 inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source 1138 stream state was inconsistent (such as zalloc or state being NULL). 1139 */ 1140 1141 ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, 1142 int bits, 1143 int value)); 1144 /* 1145 This function inserts bits in the inflate input stream. The intent is 1146 that this function is used to start inflating at a bit position in the 1147 middle of a byte. The provided bits will be used before any bytes are used 1148 from next_in. This function should only be used with raw inflate, and 1149 should be used before the first inflate() call after inflateInit2() or 1150 inflateReset(). bits must be less than or equal to 16, and that many of the 1151 least significant bits of value will be inserted in the input. 1152 1153 inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source 1154 stream state was inconsistent. 1155 */ 1156 1157 ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, 1158 gz_headerp head)); 1159 /* 1160 inflateGetHeader() requests that gzip header information be stored in the 1161 provided gz_header structure. inflateGetHeader() may be called after 1162 inflateInit2() or inflateReset(), and before the first call of inflate(). 1163 As inflate() processes the gzip stream, head->done is zero until the header 1164 is completed, at which time head->done is set to one. If a zlib stream is 1165 being decoded, then head->done is set to -1 to indicate that there will be 1166 no gzip header information forthcoming. Note that Z_BLOCK can be used to 1167 force inflate() to return immediately after header processing is complete 1168 and before any actual data is decompressed. 1169 1170 The text, time, xflags, and os fields are filled in with the gzip header 1171 contents. hcrc is set to true if there is a header CRC. (The header CRC 1172 was valid if done is set to one.) If extra is not Z_NULL, then extra_max 1173 contains the maximum number of bytes to write to extra. Once done is true, 1174 extra_len contains the actual extra field length, and extra contains the 1175 extra field, or that field truncated if extra_max is less than extra_len. 1176 If name is not Z_NULL, then up to name_max characters are written there, 1177 terminated with a zero unless the length is greater than name_max. If 1178 comment is not Z_NULL, then up to comm_max characters are written there, 1179 terminated with a zero unless the length is greater than comm_max. When 1180 any of extra, name, or comment are not Z_NULL and the respective field is 1181 not present in the header, then that field is set to Z_NULL to signal its 1182 absence. This allows the use of deflateSetHeader() with the returned 1183 structure to duplicate the header. However if those fields are set to 1184 allocated memory, then the application will need to save those pointers 1185 elsewhere so that they can be eventually freed. 1186 1187 If inflateGetHeader is not used, then the header information is simply 1188 discarded. The header is always checked for validity, including the header 1189 CRC if present. inflateReset() will reset the process to discard the header 1190 information. The application would need to call inflateGetHeader() again to 1191 retrieve the header from the next gzip stream. 1192 1193 inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source 1194 stream state was inconsistent. 1195 */ 1196 1197 /* 1198 ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, 1199 unsigned char FAR *window)); 1200 1201 Initialize the internal stream state for decompression using inflateBack() 1202 calls. The fields zalloc, zfree and opaque in strm must be initialized 1203 before the call. If zalloc and zfree are Z_NULL, then the default library- 1204 derived memory allocation routines are used. windowBits is the base two 1205 logarithm of the window size, in the range 8..15. window is a caller 1206 supplied buffer of that size. Except for special applications where it is 1207 assured that deflate was used with small window sizes, windowBits must be 15 1208 and a 32K byte window must be supplied to be able to decompress general 1209 deflate streams. 1210 1211 See inflateBack() for the usage of these routines. 1212 1213 inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of 1214 the paramaters are invalid, Z_MEM_ERROR if the internal state could not 1215 be allocated, or Z_VERSION_ERROR if the version of the library does not 1216 match the version of the header file. 1217 */ 1218 1219 typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); 1220 typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); 1221 1222 ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, 1223 in_func in, void FAR *in_desc, 1224 out_func out, void FAR *out_desc)); 1225 /* 1226 inflateBack() does a raw inflate with a single call using a call-back 1227 interface for input and output. This is more efficient than inflate() for 1228 file i/o applications in that it avoids copying between the output and the 1229 sliding window by simply making the window itself the output buffer. This 1230 function trusts the application to not change the output buffer passed by 1231 the output function, at least until inflateBack() returns. 1232 1233 inflateBackInit() must be called first to allocate the internal state 1234 and to initialize the state with the user-provided window buffer. 1235 inflateBack() may then be used multiple times to inflate a complete, raw 1236 deflate stream with each call. inflateBackEnd() is then called to free 1237 the allocated state. 1238 1239 A raw deflate stream is one with no zlib or gzip header or trailer. 1240 This routine would normally be used in a utility that reads zip or gzip 1241 files and writes out uncompressed files. The utility would decode the 1242 header and process the trailer on its own, hence this routine expects 1243 only the raw deflate stream to decompress. This is different from the 1244 normal behavior of inflate(), which expects either a zlib or gzip header and 1245 trailer around the deflate stream. 1246 1247 inflateBack() uses two subroutines supplied by the caller that are then 1248 called by inflateBack() for input and output. inflateBack() calls those 1249 routines until it reads a complete deflate stream and writes out all of the 1250 uncompressed data, or until it encounters an error. The function's 1251 parameters and return types are defined above in the in_func and out_func 1252 typedefs. inflateBack() will call in(in_desc, &buf) which should return the 1253 number of bytes of provided input, and a pointer to that input in buf. If 1254 there is no input available, in() must return zero--buf is ignored in that 1255 case--and inflateBack() will return a buffer error. inflateBack() will call 1256 out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() 1257 should return zero on success, or non-zero on failure. If out() returns 1258 non-zero, inflateBack() will return with an error. Neither in() nor out() 1259 are permitted to change the contents of the window provided to 1260 inflateBackInit(), which is also the buffer that out() uses to write from. 1261 The length written by out() will be at most the window size. Any non-zero 1262 amount of input may be provided by in(). 1263 1264 For convenience, inflateBack() can be provided input on the first call by 1265 setting strm->next_in and strm->avail_in. If that input is exhausted, then 1266 in() will be called. Therefore strm->next_in must be initialized before 1267 calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called 1268 immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in 1269 must also be initialized, and then if strm->avail_in is not zero, input will 1270 initially be taken from strm->next_in[0 .. strm->avail_in - 1]. 1271 1272 The in_desc and out_desc parameters of inflateBack() is passed as the 1273 first parameter of in() and out() respectively when they are called. These 1274 descriptors can be optionally used to pass any information that the caller- 1275 supplied in() and out() functions need to do their job. 1276 1277 On return, inflateBack() will set strm->next_in and strm->avail_in to 1278 pass back any unused input that was provided by the last in() call. The 1279 return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR 1280 if in() or out() returned an error, Z_DATA_ERROR if there was a format 1281 error in the deflate stream (in which case strm->msg is set to indicate the 1282 nature of the error), or Z_STREAM_ERROR if the stream was not properly 1283 initialized. In the case of Z_BUF_ERROR, an input or output error can be 1284 distinguished using strm->next_in which will be Z_NULL only if in() returned 1285 an error. If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to 1286 out() returning non-zero. (in() will always be called before out(), so 1287 strm->next_in is assured to be defined if out() returns non-zero.) Note 1288 that inflateBack() cannot return Z_OK. 1289 */ 1290 1291 ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); 1292 /* 1293 All memory allocated by inflateBackInit() is freed. 1294 1295 inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream 1296 state was inconsistent. 1297 */ 1298 1299 ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); 1300 /* Return flags indicating compile-time options. 1301 1302 Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: 1303 1.0: size of uInt 1304 3.2: size of uLong 1305 5.4: size of voidpf (pointer) 1306 7.6: size of z_off_t 1307 1308 Compiler, assembler, and debug options: 1309 8: ZLIB_DEBUG 1310 9: ASMV or ASMINF -- use ASM code 1311 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention 1312 11: 0 (reserved) 1313 1314 One-time table building (smaller code, but not thread-safe if true): 1315 12: BUILDFIXED -- build static block decoding tables when needed 1316 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed 1317 14,15: 0 (reserved) 1318 1319 Library content (indicates missing functionality): 1320 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking 1321 deflate code when not needed) 1322 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect 1323 and decode gzip streams (to avoid linking crc code) 1324 18-19: 0 (reserved) 1325 1326 Operation variations (changes in library functionality): 1327 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate 1328 21: FASTEST -- deflate algorithm with only one, lowest compression level 1329 22,23: 0 (reserved) 1330 1331 The sprintf variant used by gzprintf (zero is best): 1332 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format 1333 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! 1334 26: 0 = returns value, 1 = void -- 1 means inferred string length returned 1335 1336 Remainder: 1337 27-31: 0 (reserved) 1338 */ 1339 1340 1341 /* utility functions */ 1342 1343 /* 1344 The following utility functions are implemented on top of the 1345 basic stream-oriented functions. To simplify the interface, some 1346 default options are assumed (compression level and memory usage, 1347 standard memory allocation functions). The source code of these 1348 utility functions can easily be modified if you need special options. 1349 */ 1350 1351 ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, 1352 const Bytef *source, uLong sourceLen)); 1353 /* 1354 Compresses the source buffer into the destination buffer. sourceLen is 1355 the byte length of the source buffer. Upon entry, destLen is the total 1356 size of the destination buffer, which must be at least the value returned 1357 by compressBound(sourceLen). Upon exit, destLen is the actual size of the 1358 compressed buffer. 1359 This function can be used to compress a whole file at once if the 1360 input file is mmap'ed. 1361 compress returns Z_OK if success, Z_MEM_ERROR if there was not 1362 enough memory, Z_BUF_ERROR if there was not enough room in the output 1363 buffer. 1364 */ 1365 1366 ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, 1367 const Bytef *source, uLong sourceLen, 1368 int level)); 1369 /* 1370 Compresses the source buffer into the destination buffer. The level 1371 parameter has the same meaning as in deflateInit. sourceLen is the byte 1372 length of the source buffer. Upon entry, destLen is the total size of the 1373 destination buffer, which must be at least the value returned by 1374 compressBound(sourceLen). Upon exit, destLen is the actual size of the 1375 compressed buffer. 1376 1377 compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 1378 memory, Z_BUF_ERROR if there was not enough room in the output buffer, 1379 Z_STREAM_ERROR if the level parameter is invalid. 1380 */ 1381 1382 ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); 1383 /* 1384 compressBound() returns an upper bound on the compressed size after 1385 compress() or compress2() on sourceLen bytes. It would be used before 1386 a compress() or compress2() call to allocate the destination buffer. 1387 */ 1388 1389 ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, 1390 const Bytef *source, uLong sourceLen)); 1391 /* 1392 Decompresses the source buffer into the destination buffer. sourceLen is 1393 the byte length of the source buffer. Upon entry, destLen is the total 1394 size of the destination buffer, which must be large enough to hold the 1395 entire uncompressed data. (The size of the uncompressed data must have 1396 been saved previously by the compressor and transmitted to the decompressor 1397 by some mechanism outside the scope of this compression library.) 1398 Upon exit, destLen is the actual size of the compressed buffer. 1399 This function can be used to decompress a whole file at once if the 1400 input file is mmap'ed. 1401 1402 uncompress returns Z_OK if success, Z_MEM_ERROR if there was not 1403 enough memory, Z_BUF_ERROR if there was not enough room in the output 1404 buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. 1405 */ 1406 1407 1408 typedef voidp gzFile; 1409 1410 ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); 1411 /* 1412 Opens a gzip (.gz) file for reading or writing. The mode parameter 1413 is as in fopen ("rb" or "wb") but can also include a compression level 1414 ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for 1415 Huffman only compression as in "wb1h", or 'R' for run-length encoding 1416 as in "wb1R". (See the description of deflateInit2 for more information 1417 about the strategy parameter.) 1418 1419 gzopen can be used to read a file which is not in gzip format; in this 1420 case gzread will directly read from the file without decompression. 1421 1422 gzopen returns NULL if the file could not be opened or if there was 1423 insufficient memory to allocate the (de)compression state; errno 1424 can be checked to distinguish the two cases (if errno is zero, the 1425 zlib error is Z_MEM_ERROR). */ 1426 1427 ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); 1428 /* 1429 gzdopen() associates a gzFile with the file descriptor fd. File 1430 descriptors are obtained from calls like open, dup, creat, pipe or 1431 fileno (in the file has been previously opened with fopen). 1432 The mode parameter is as in gzopen. 1433 The next call of gzclose on the returned gzFile will also close the 1434 file descriptor fd, just like fclose(fdopen(fd), mode) closes the file 1435 descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). 1436 gzdopen returns NULL if there was insufficient memory to allocate 1437 the (de)compression state. 1438 */ 1439 1440 ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); 1441 /* 1442 Dynamically update the compression level or strategy. See the description 1443 of deflateInit2 for the meaning of these parameters. 1444 gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not 1445 opened for writing. 1446 */ 1447 1448 ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); 1449 /* 1450 Reads the given number of uncompressed bytes from the compressed file. 1451 If the input file was not in gzip format, gzread copies the given number 1452 of bytes into the buffer. 1453 gzread returns the number of uncompressed bytes actually read (0 for 1454 end of file, -1 for error). */ 1455 1456 ZEXTERN int ZEXPORT gzwrite OF((gzFile file, 1457 voidpc buf, unsigned len)); 1458 /* 1459 Writes the given number of uncompressed bytes into the compressed file. 1460 gzwrite returns the number of uncompressed bytes actually written 1461 (0 in case of error). 1462 */ 1463 1464 ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); 1465 /* 1466 Converts, formats, and writes the args to the compressed file under 1467 control of the format string, as in fprintf. gzprintf returns the number of 1468 uncompressed bytes actually written (0 in case of error). The number of 1469 uncompressed bytes written is limited to 4095. The caller should assure that 1470 this limit is not exceeded. If it is exceeded, then gzprintf() will return 1471 return an error (0) with nothing written. In this case, there may also be a 1472 buffer overflow with unpredictable consequences, which is possible only if 1473 zlib was compiled with the insecure functions sprintf() or vsprintf() 1474 because the secure snprintf() or vsnprintf() functions were not available. 1475 */ 1476 1477 ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); 1478 /* 1479 Writes the given null-terminated string to the compressed file, excluding 1480 the terminating null character. 1481 gzputs returns the number of characters written, or -1 in case of error. 1482 */ 1483 1484 ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); 1485 /* 1486 Reads bytes from the compressed file until len-1 characters are read, or 1487 a newline character is read and transferred to buf, or an end-of-file 1488 condition is encountered. The string is then terminated with a null 1489 character. 1490 gzgets returns buf, or Z_NULL in case of error. 1491 */ 1492 1493 ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); 1494 /* 1495 Writes c, converted to an unsigned char, into the compressed file. 1496 gzputc returns the value that was written, or -1 in case of error. 1497 */ 1498 1499 ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); 1500 /* 1501 Reads one byte from the compressed file. gzgetc returns this byte 1502 or -1 in case of end of file or error. 1503 */ 1504 1505 ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); 1506 /* 1507 Push one character back onto the stream to be read again later. 1508 Only one character of push-back is allowed. gzungetc() returns the 1509 character pushed, or -1 on failure. gzungetc() will fail if a 1510 character has been pushed but not read yet, or if c is -1. The pushed 1511 character will be discarded if the stream is repositioned with gzseek() 1512 or gzrewind(). 1513 */ 1514 1515 ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); 1516 /* 1517 Flushes all pending output into the compressed file. The parameter 1518 flush is as in the deflate() function. The return value is the zlib 1519 error number (see function gzerror below). gzflush returns Z_OK if 1520 the flush parameter is Z_FINISH and all output could be flushed. 1521 gzflush should be called only when strictly necessary because it can 1522 degrade compression. 1523 */ 1524 1525 ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, 1526 z_off_t offset, int whence)); 1527 /* 1528 Sets the starting position for the next gzread or gzwrite on the 1529 given compressed file. The offset represents a number of bytes in the 1530 uncompressed data stream. The whence parameter is defined as in lseek(2); 1531 the value SEEK_END is not supported. 1532 If the file is opened for reading, this function is emulated but can be 1533 extremely slow. If the file is opened for writing, only forward seeks are 1534 supported; gzseek then compresses a sequence of zeroes up to the new 1535 starting position. 1536 1537 gzseek returns the resulting offset location as measured in bytes from 1538 the beginning of the uncompressed stream, or -1 in case of error, in 1539 particular if the file is opened for writing and the new starting position 1540 would be before the current position. 1541 */ 1542 1543 ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); 1544 /* 1545 Rewinds the given file. This function is supported only for reading. 1546 1547 gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) 1548 */ 1549 1550 ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); 1551 /* 1552 Returns the starting position for the next gzread or gzwrite on the 1553 given compressed file. This position represents a number of bytes in the 1554 uncompressed data stream. 1555 1556 gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) 1557 */ 1558 1559 ZEXTERN int ZEXPORT gzeof OF((gzFile file)); 1560 /* 1561 Returns 1 when EOF has previously been detected reading the given 1562 input stream, otherwise zero. 1563 */ 1564 1565 ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); 1566 /* 1567 Returns 1 if file is being read directly without decompression, otherwise 1568 zero. 1569 */ 1570 1571 ZEXTERN int ZEXPORT gzclose OF((gzFile file)); 1572 /* 1573 Flushes all pending output if necessary, closes the compressed file 1574 and deallocates all the (de)compression state. The return value is the zlib 1575 error number (see function gzerror below). 1576 */ 1577 1578 ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); 1579 /* 1580 Returns the error message for the last error which occurred on the 1581 given compressed file. errnum is set to zlib error number. If an 1582 error occurred in the file system and not in the compression library, 1583 errnum is set to Z_ERRNO and the application may consult errno 1584 to get the exact error code. 1585 */ 1586 1587 ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); 1588 /* 1589 Clears the error and end-of-file flags for file. This is analogous to the 1590 clearerr() function in stdio. This is useful for continuing to read a gzip 1591 file that is being written concurrently. 1592 */ 1593 1594 /* checksum functions */ 1595 1596 /* 1597 These functions are not related to compression but are exported 1598 anyway because they might be useful in applications using the 1599 compression library. 1600 */ 1601 1602 ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); 1603 /* 1604 Update a running Adler-32 checksum with the bytes buf[0..len-1] and 1605 return the updated checksum. If buf is NULL, this function returns 1606 the required initial value for the checksum. 1607 An Adler-32 checksum is almost as reliable as a CRC32 but can be computed 1608 much faster. Usage example: 1609 1610 uLong adler = adler32(0L, Z_NULL, 0); 1611 1612 while (read_buffer(buffer, length) != EOF) { 1613 adler = adler32(adler, buffer, length); 1614 } 1615 if (adler != original_adler) error(); 1616 */ 1617 1618 ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, 1619 z_off_t len2)); 1620 /* 1621 Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 1622 and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for 1623 each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of 1624 seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. 1625 */ 1626 1627 #if !defined(_KERNEL) && !defined(_STANDALONE) 1628 ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); 1629 #endif 1630 /* 1631 Update a running CRC-32 with the bytes buf[0..len-1] and return the 1632 updated CRC-32. If buf is NULL, this function returns the required initial 1633 value for the for the crc. Pre- and post-conditioning (one's complement) is 1634 performed within this function so it shouldn't be done by the application. 1635 Usage example: 1636 1637 uLong crc = crc32(0L, Z_NULL, 0); 1638 1639 while (read_buffer(buffer, length) != EOF) { 1640 crc = crc32(crc, buffer, length); 1641 } 1642 if (crc != original_crc) error(); 1643 */ 1644 1645 ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); 1646 1647 /* 1648 Combine two CRC-32 check values into one. For two sequences of bytes, 1649 seq1 and seq2 with lengths len1 and len2, CRC-32 check values were 1650 calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 1651 check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and 1652 len2. 1653 */ 1654 1655 1656 /* various hacks, don't look :) */ 1657 1658 /* deflateInit and inflateInit are macros to allow checking the zlib version 1659 * and the compiler's view of z_stream: 1660 */ 1661 ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, 1662 const char *version, int stream_size)); 1663 ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, 1664 const char *version, int stream_size)); 1665 ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, 1666 int windowBits, int memLevel, 1667 int strategy, const char *version, 1668 int stream_size)); 1669 ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, 1670 const char *version, int stream_size)); 1671 ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, 1672 unsigned char FAR *window, 1673 const char *version, 1674 int stream_size)); 1675 #define deflateInit(strm, level) \ 1676 deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) 1677 #define inflateInit(strm) \ 1678 inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) 1679 #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ 1680 deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ 1681 (strategy), ZLIB_VERSION, sizeof(z_stream)) 1682 #define inflateInit2(strm, windowBits) \ 1683 inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) 1684 #define inflateBackInit(strm, windowBits, window) \ 1685 inflateBackInit_((strm), (windowBits), (window), \ 1686 ZLIB_VERSION, sizeof(z_stream)) 1687 1688 1689 #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) 1690 struct internal_state {int dummy;}; /* hack for buggy compilers */ 1691 #endif 1692 1693 ZEXTERN const char * ZEXPORT zError OF((int)); 1694 ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); 1695 ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); 1696 1697 #ifdef __cplusplus 1698 } 1699 #endif 1700 1701 #endif /* ZLIB_H */ 1702