1/* 2 * Copyright (c) 2003 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_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. Please obtain a copy of the License at 10 * http://www.opensource.apple.com/apsl/ and read it before using this 11 * file. 12 * 13 * The Original Code and all software distributed under the License are 14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 18 * Please see the License for the specific language governing rights and 19 * limitations under the License. 20 * 21 * @APPLE_LICENSE_HEADER_END@ 22 */ 23/* $Id: zlib.h,v 1.3 2003/08/14 00:00:39 callie Exp $ */ 24 25/* 26 * This file is derived from zlib.h and zconf.h from the zlib-0.95 27 * distribution by Jean-loup Gailly and Mark Adler, with some additions 28 * by Paul Mackerras to aid in implementing Deflate compression and 29 * decompression for PPP packets. 30 */ 31 32/* zlib.h -- interface of the 'zlib' general purpose compression library 33 version 0.95, Aug 16th, 1995. 34 35 Copyright (C) 1995 Jean-loup Gailly and Mark Adler 36 37 This software is provided 'as-is', without any express or implied 38 warranty. In no event will the authors be held liable for any damages 39 arising from the use of this software. 40 41 Permission is granted to anyone to use this software for any purpose, 42 including commercial applications, and to alter it and redistribute it 43 freely, subject to the following restrictions: 44 45 1. The origin of this software must not be misrepresented; you must not 46 claim that you wrote the original software. If you use this software 47 in a product, an acknowledgment in the product documentation would be 48 appreciated but is not required. 49 2. Altered source versions must be plainly marked as such, and must not be 50 misrepresented as being the original software. 51 3. This notice may not be removed or altered from any source distribution. 52 53 Jean-loup Gailly Mark Adler 54 gzip@prep.ai.mit.edu madler@alumni.caltech.edu 55 */ 56 57#ifndef _ZLIB_H 58#define _ZLIB_H 59 60/* #include "zconf.h" */ /* included directly here */ 61 62/* zconf.h -- configuration of the zlib compression library 63 * Copyright (C) 1995 Jean-loup Gailly. 64 * For conditions of distribution and use, see copyright notice in zlib.h 65 */ 66 67/* From: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp */ 68 69/* 70 The library does not install any signal handler. It is recommended to 71 add at least a handler for SIGSEGV when decompressing; the library checks 72 the consistency of the input data whenever possible but may go nuts 73 for some forms of corrupted input. 74 */ 75 76/* 77 * Compile with -DMAXSEG_64K if the alloc function cannot allocate more 78 * than 64k bytes at a time (needed on systems with 16-bit int). 79 * Compile with -DUNALIGNED_OK if it is OK to access shorts or ints 80 * at addresses which are not a multiple of their size. 81 * Under DOS, -DFAR=far or -DFAR=__far may be needed. 82 */ 83 84#ifndef STDC 85# if defined(MSDOS) || defined(__STDC__) || defined(__cplusplus) 86# define STDC 87# endif 88#endif 89 90#ifdef __MWERKS__ /* Metrowerks CodeWarrior declares fileno() in unix.h */ 91# include <unix.h> 92#endif 93 94/* Maximum value for memLevel in deflateInit2 */ 95#ifndef MAX_MEM_LEVEL 96# ifdef MAXSEG_64K 97# define MAX_MEM_LEVEL 8 98# else 99# define MAX_MEM_LEVEL 9 100# endif 101#endif 102 103#ifndef FAR 104# define FAR 105#endif 106 107/* Maximum value for windowBits in deflateInit2 and inflateInit2 */ 108#ifndef MAX_WBITS 109# define MAX_WBITS 15 /* 32K LZ77 window */ 110#endif 111 112/* The memory requirements for deflate are (in bytes): 113 1 << (windowBits+2) + 1 << (memLevel+9) 114 that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) 115 plus a few kilobytes for small objects. For example, if you want to reduce 116 the default memory requirements from 256K to 128K, compile with 117 make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" 118 Of course this will generally degrade compression (there's no free lunch). 119 120 The memory requirements for inflate are (in bytes) 1 << windowBits 121 that is, 32K for windowBits=15 (default value) plus a few kilobytes 122 for small objects. 123*/ 124 125 /* Type declarations */ 126 127#ifndef OF /* function prototypes */ 128# ifdef STDC 129# define OF(args) args 130# else 131# define OF(args) () 132# endif 133#endif 134 135typedef unsigned char Byte; /* 8 bits */ 136typedef unsigned int uInt; /* 16 bits or more */ 137typedef unsigned long uLong; /* 32 bits or more */ 138 139typedef Byte FAR Bytef; 140typedef char FAR charf; 141typedef int FAR intf; 142typedef uInt FAR uIntf; 143typedef uLong FAR uLongf; 144 145#ifdef STDC 146 typedef void FAR *voidpf; 147 typedef void *voidp; 148#else 149 typedef Byte FAR *voidpf; 150 typedef Byte *voidp; 151#endif 152 153/* end of original zconf.h */ 154 155#define ZLIB_VERSION "0.95P" 156 157/* 158 The 'zlib' compression library provides in-memory compression and 159 decompression functions, including integrity checks of the uncompressed 160 data. This version of the library supports only one compression method 161 (deflation) but other algorithms may be added later and will have the same 162 stream interface. 163 164 For compression the application must provide the output buffer and 165 may optionally provide the input buffer for optimization. For decompression, 166 the application must provide the input buffer and may optionally provide 167 the output buffer for optimization. 168 169 Compression can be done in a single step if the buffers are large 170 enough (for example if an input file is mmap'ed), or can be done by 171 repeated calls of the compression function. In the latter case, the 172 application must provide more input and/or consume the output 173 (providing more output space) before each call. 174*/ 175 176typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); 177typedef void (*free_func) OF((voidpf opaque, voidpf address, uInt nbytes)); 178 179struct internal_state; 180 181typedef struct z_stream_s { 182 Bytef *next_in; /* next input byte */ 183 uInt avail_in; /* number of bytes available at next_in */ 184 uLong total_in; /* total nb of input bytes read so far */ 185 186 Bytef *next_out; /* next output byte should be put there */ 187 uInt avail_out; /* remaining free space at next_out */ 188 uLong total_out; /* total nb of bytes output so far */ 189 190 char *msg; /* last error message, NULL if no error */ 191 struct internal_state FAR *state; /* not visible by applications */ 192 193 alloc_func zalloc; /* used to allocate the internal state */ 194 free_func zfree; /* used to free the internal state */ 195 voidp opaque; /* private data object passed to zalloc and zfree */ 196 197 Byte data_type; /* best guess about the data type: ascii or binary */ 198 199} z_stream; 200 201/* 202 The application must update next_in and avail_in when avail_in has 203 dropped to zero. It must update next_out and avail_out when avail_out 204 has dropped to zero. The application must initialize zalloc, zfree and 205 opaque before calling the init function. All other fields are set by the 206 compression library and must not be updated by the application. 207 208 The opaque value provided by the application will be passed as the first 209 parameter for calls of zalloc and zfree. This can be useful for custom 210 memory management. The compression library attaches no meaning to the 211 opaque value. 212 213 zalloc must return Z_NULL if there is not enough memory for the object. 214 On 16-bit systems, the functions zalloc and zfree must be able to allocate 215 exactly 65536 bytes, but will not be required to allocate more than this 216 if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, 217 pointers returned by zalloc for objects of exactly 65536 bytes *must* 218 have their offset normalized to zero. The default allocation function 219 provided by this library ensures this (see zutil.c). To reduce memory 220 requirements and avoid any allocation of 64K objects, at the expense of 221 compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). 222 223 The fields total_in and total_out can be used for statistics or 224 progress reports. After compression, total_in holds the total size of 225 the uncompressed data and may be saved for use in the decompressor 226 (particularly if the decompressor wants to decompress everything in 227 a single step). 228*/ 229 230 /* constants */ 231 232#define Z_NO_FLUSH 0 233#define Z_PARTIAL_FLUSH 1 234#define Z_FULL_FLUSH 2 235#define Z_SYNC_FLUSH 3 /* experimental: partial_flush + byte align */ 236#define Z_FINISH 4 237#define Z_PACKET_FLUSH 5 238/* See deflate() below for the usage of these constants */ 239 240#define Z_OK 0 241#define Z_STREAM_END 1 242#define Z_ERRNO (-1) 243#define Z_STREAM_ERROR (-2) 244#define Z_DATA_ERROR (-3) 245#define Z_MEM_ERROR (-4) 246#define Z_BUF_ERROR (-5) 247/* error codes for the compression/decompression functions */ 248 249#define Z_BEST_SPEED 1 250#define Z_BEST_COMPRESSION 9 251#define Z_DEFAULT_COMPRESSION (-1) 252/* compression levels */ 253 254#define Z_FILTERED 1 255#define Z_HUFFMAN_ONLY 2 256#define Z_DEFAULT_STRATEGY 0 257 258#define Z_BINARY 0 259#define Z_ASCII 1 260#define Z_UNKNOWN 2 261/* Used to set the data_type field */ 262 263#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ 264 265extern char *zlib_version; 266/* The application can compare zlib_version and ZLIB_VERSION for consistency. 267 If the first character differs, the library code actually used is 268 not compatible with the zlib.h header file used by the application. 269 */ 270 271 /* basic functions */ 272 273extern int deflateInit OF((z_stream *strm, int level)); 274/* 275 Initializes the internal stream state for compression. The fields 276 zalloc, zfree and opaque must be initialized before by the caller. 277 If zalloc and zfree are set to Z_NULL, deflateInit updates them to 278 use default allocation functions. 279 280 The compression level must be Z_DEFAULT_COMPRESSION, or between 1 and 9: 281 1 gives best speed, 9 gives best compression. Z_DEFAULT_COMPRESSION requests 282 a default compromise between speed and compression (currently equivalent 283 to level 6). 284 285 deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not 286 enough memory, Z_STREAM_ERROR if level is not a valid compression level. 287 msg is set to null if there is no error message. deflateInit does not 288 perform any compression: this will be done by deflate(). 289*/ 290 291 292extern int deflate OF((z_stream *strm, int flush)); 293/* 294 Performs one or both of the following actions: 295 296 - Compress more input starting at next_in and update next_in and avail_in 297 accordingly. If not all input can be processed (because there is not 298 enough room in the output buffer), next_in and avail_in are updated and 299 processing will resume at this point for the next call of deflate(). 300 301 - Provide more output starting at next_out and update next_out and avail_out 302 accordingly. This action is forced if the parameter flush is non zero. 303 Forcing flush frequently degrades the compression ratio, so this parameter 304 should be set only when necessary (in interactive applications). 305 Some output may be provided even if flush is not set. 306 307 Before the call of deflate(), the application should ensure that at least 308 one of the actions is possible, by providing more input and/or consuming 309 more output, and updating avail_in or avail_out accordingly; avail_out 310 should never be zero before the call. The application can consume the 311 compressed output when it wants, for example when the output buffer is full 312 (avail_out == 0), or after each call of deflate(). 313 314 If the parameter flush is set to Z_PARTIAL_FLUSH, the current compression 315 block is terminated and flushed to the output buffer so that the 316 decompressor can get all input data available so far. For method 9, a future 317 variant on method 8, the current block will be flushed but not terminated. 318 If flush is set to Z_FULL_FLUSH, the compression block is terminated, a 319 special marker is output and the compression dictionary is discarded; this 320 is useful to allow the decompressor to synchronize if one compressed block 321 has been damaged (see inflateSync below). Flushing degrades compression and 322 so should be used only when necessary. Using Z_FULL_FLUSH too often can 323 seriously degrade the compression. If deflate returns with avail_out == 0, 324 this function must be called again with the same value of the flush 325 parameter and more output space (updated avail_out), until the flush is 326 complete (deflate returns with non-zero avail_out). 327 328 If the parameter flush is set to Z_PACKET_FLUSH, the compression 329 block is terminated, and a zero-length stored block is output, 330 omitting the length bytes (the effect of this is that the 3-bit type 331 code 000 for a stored block is output, and the output is then 332 byte-aligned). This is designed for use at the end of a PPP packet. 333 In addition, if the current compression block contains all the data 334 since the last Z_PACKET_FLUSH, it is never output as a stored block. 335 If the current compression block output as a static or dynamic block 336 would not be at least `minCompression' bytes smaller than the 337 original data, then nothing is output for that block. (The type 338 code for the zero-length stored block is still output, resulting in 339 a single zero byte being output for the whole packet.) 340 `MinCompression' is a parameter to deflateInit2, or 0 if deflateInit 341 is used. 342 343 If the parameter flush is set to Z_FINISH, all pending input is processed, 344 all pending output is flushed and deflate returns with Z_STREAM_END if there 345 was enough output space; if deflate returns with Z_OK, this function must be 346 called again with Z_FINISH and more output space (updated avail_out) but no 347 more input data, until it returns with Z_STREAM_END or an error. After 348 deflate has returned Z_STREAM_END, the only possible operations on the 349 stream are deflateReset or deflateEnd. 350 351 Z_FINISH can be used immediately after deflateInit if all the compression 352 is to be done in a single step. In this case, avail_out must be at least 353 0.1% larger than avail_in plus 12 bytes. If deflate does not return 354 Z_STREAM_END, then it must be called again as described above. 355 356 deflate() may update data_type if it can make a good guess about 357 the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered 358 binary. This field is only for information purposes and does not affect 359 the compression algorithm in any manner. 360 361 deflate() returns Z_OK if some progress has been made (more input 362 processed or more output produced), Z_STREAM_END if all input has been 363 consumed and all output has been produced (only when flush is set to 364 Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example 365 if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible. 366*/ 367 368 369extern int deflateEnd OF((z_stream *strm)); 370/* 371 All dynamically allocated data structures for this stream are freed. 372 This function discards any unprocessed input and does not flush any 373 pending output. 374 375 deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the 376 stream state was inconsistent. In the error case, msg may be set 377 but then points to a static string (which must not be deallocated). 378*/ 379 380 381extern int inflateInit OF((z_stream *strm)); 382/* 383 Initializes the internal stream state for decompression. The fields 384 zalloc and zfree must be initialized before by the caller. If zalloc and 385 zfree are set to Z_NULL, inflateInit updates them to use default allocation 386 functions. 387 388 inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not 389 enough memory. msg is set to null if there is no error message. 390 inflateInit does not perform any decompression: this will be done by 391 inflate(). 392*/ 393 394 395extern int inflate OF((z_stream *strm, int flush)); 396/* 397 Performs one or both of the following actions: 398 399 - Decompress more input starting at next_in and update next_in and avail_in 400 accordingly. If not all input can be processed (because there is not 401 enough room in the output buffer), next_in is updated and processing 402 will resume at this point for the next call of inflate(). 403 404 - Provide more output starting at next_out and update next_out and avail_out 405 accordingly. inflate() always provides as much output as possible 406 (until there is no more input data or no more space in the output buffer). 407 408 Before the call of inflate(), the application should ensure that at least 409 one of the actions is possible, by providing more input and/or consuming 410 more output, and updating the next_* and avail_* values accordingly. 411 The application can consume the uncompressed output when it wants, for 412 example when the output buffer is full (avail_out == 0), or after each 413 call of inflate(). 414 415 If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH, 416 inflate flushes as much output as possible to the output buffer. The 417 flushing behavior of inflate is not specified for values of the flush 418 parameter other than Z_PARTIAL_FLUSH, Z_PACKET_FLUSH or Z_FINISH, but the 419 current implementation actually flushes as much output as possible 420 anyway. For Z_PACKET_FLUSH, inflate checks that once all the input data 421 has been consumed, it is expecting to see the length field of a stored 422 block; if not, it returns Z_DATA_ERROR. 423 424 inflate() should normally be called until it returns Z_STREAM_END or an 425 error. However if all decompression is to be performed in a single step 426 (a single call of inflate), the parameter flush should be set to 427 Z_FINISH. In this case all pending input is processed and all pending 428 output is flushed; avail_out must be large enough to hold all the 429 uncompressed data. (The size of the uncompressed data may have been saved 430 by the compressor for this purpose.) The next operation on this stream must 431 be inflateEnd to deallocate the decompression state. The use of Z_FINISH 432 is never required, but can be used to inform inflate that a faster routine 433 may be used for the single inflate() call. 434 435 inflate() returns Z_OK if some progress has been made (more input 436 processed or more output produced), Z_STREAM_END if the end of the 437 compressed data has been reached and all uncompressed output has been 438 produced, Z_DATA_ERROR if the input data was corrupted, Z_STREAM_ERROR if 439 the stream structure was inconsistent (for example if next_in or next_out 440 was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no 441 progress is possible or if there was not enough room in the output buffer 442 when Z_FINISH is used. In the Z_DATA_ERROR case, the application may then 443 call inflateSync to look for a good compression block. */ 444 445 446extern int inflateEnd OF((z_stream *strm)); 447/* 448 All dynamically allocated data structures for this stream are freed. 449 This function discards any unprocessed input and does not flush any 450 pending output. 451 452 inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state 453 was inconsistent. In the error case, msg may be set but then points to a 454 static string (which must not be deallocated). 455*/ 456 457 /* advanced functions */ 458 459/* 460 The following functions are needed only in some special applications. 461*/ 462 463extern int deflateInit2 OF((z_stream *strm, 464 int level, 465 int method, 466 int windowBits, 467 int memLevel, 468 int strategy, 469 int minCompression)); 470/* 471 This is another version of deflateInit with more compression options. The 472 fields next_in, zalloc and zfree must be initialized before by the caller. 473 474 The method parameter is the compression method. It must be 8 in this 475 version of the library. (Method 9 will allow a 64K history buffer and 476 partial block flushes.) 477 478 The windowBits parameter is the base two logarithm of the window size 479 (the size of the history buffer). It should be in the range 8..15 for this 480 version of the library (the value 16 will be allowed for method 9). Larger 481 values of this parameter result in better compression at the expense of 482 memory usage. The default value is 15 if deflateInit is used instead. 483 484 The memLevel parameter specifies how much memory should be allocated 485 for the internal compression state. memLevel=1 uses minimum memory but 486 is slow and reduces compression ratio; memLevel=9 uses maximum memory 487 for optimal speed. The default value is 8. See zconf.h for total memory 488 usage as a function of windowBits and memLevel. 489 490 The strategy parameter is used to tune the compression algorithm. Use 491 the value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data 492 produced by a filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman 493 encoding only (no string match). Filtered data consists mostly of small 494 values with a somewhat random distribution. In this case, the 495 compression algorithm is tuned to compress them better. The strategy 496 parameter only affects the compression ratio but not the correctness of 497 the compressed output even if it is not set appropriately. 498 499 The minCompression parameter specifies the minimum reduction in size 500 required for a compressed block to be output when Z_PACKET_FLUSH is 501 used (see the description of deflate above). 502 503 If next_in is not null, the library will use this buffer to hold also 504 some history information; the buffer must either hold the entire input 505 data, or have at least 1<<(windowBits+1) bytes and be writable. If next_in 506 is null, the library will allocate its own history buffer (and leave next_in 507 null). next_out need not be provided here but must be provided by the 508 application for the next call of deflate(). 509 510 If the history buffer is provided by the application, next_in must 511 must never be changed by the application since the compressor maintains 512 information inside this buffer from call to call; the application 513 must provide more input only by increasing avail_in. next_in is always 514 reset by the library in this case. 515 516 deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was 517 not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as 518 an invalid method). msg is set to null if there is no error message. 519 deflateInit2 does not perform any compression: this will be done by 520 deflate(). 521*/ 522 523extern int deflateCopy OF((z_stream *dest, 524 z_stream *source)); 525/* 526 Sets the destination stream as a complete copy of the source stream. If 527 the source stream is using an application-supplied history buffer, a new 528 buffer is allocated for the destination stream. The compressed output 529 buffer is always application-supplied. It's the responsibility of the 530 application to provide the correct values of next_out and avail_out for the 531 next call of deflate. 532 533 This function is useful when several compression strategies will be 534 tried, for example when there are several ways of pre-processing the input 535 data with a filter. The streams that will be discarded should then be freed 536 by calling deflateEnd. Note that deflateCopy duplicates the internal 537 compression state which can be quite large, so this strategy is slow and 538 can consume lots of memory. 539 540 deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not 541 enough memory, Z_STREAM_ERROR if the source stream state was inconsistent 542 (such as zalloc being NULL). msg is left unchanged in both source and 543 destination. 544*/ 545 546extern int deflateReset OF((z_stream *strm)); 547/* 548 This function is equivalent to deflateEnd followed by deflateInit, 549 but does not free and reallocate all the internal compression state. 550 The stream will keep the same compression level and any other attributes 551 that may have been set by deflateInit2. 552 553 deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source 554 stream state was inconsistent (such as zalloc or state being NULL). 555*/ 556 557extern int inflateInit2 OF((z_stream *strm, 558 int windowBits)); 559/* 560 This is another version of inflateInit with more compression options. The 561 fields next_out, zalloc and zfree must be initialized before by the caller. 562 563 The windowBits parameter is the base two logarithm of the maximum window 564 size (the size of the history buffer). It should be in the range 8..15 for 565 this version of the library (the value 16 will be allowed soon). The 566 default value is 15 if inflateInit is used instead. If a compressed stream 567 with a larger window size is given as input, inflate() will return with 568 the error code Z_DATA_ERROR instead of trying to allocate a larger window. 569 570 If next_out is not null, the library will use this buffer for the history 571 buffer; the buffer must either be large enough to hold the entire output 572 data, or have at least 1<<windowBits bytes. If next_out is null, the 573 library will allocate its own buffer (and leave next_out null). next_in 574 need not be provided here but must be provided by the application for the 575 next call of inflate(). 576 577 If the history buffer is provided by the application, next_out must 578 never be changed by the application since the decompressor maintains 579 history information inside this buffer from call to call; the application 580 can only reset next_out to the beginning of the history buffer when 581 avail_out is zero and all output has been consumed. 582 583 inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was 584 not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as 585 windowBits < 8). msg is set to null if there is no error message. 586 inflateInit2 does not perform any decompression: this will be done by 587 inflate(). 588*/ 589 590extern int inflateSync OF((z_stream *strm)); 591/* 592 Skips invalid compressed data until the special marker (see deflate() 593 above) can be found, or until all available input is skipped. No output 594 is provided. 595 596 inflateSync returns Z_OK if the special marker has been found, Z_BUF_ERROR 597 if no more input was provided, Z_DATA_ERROR if no marker has been found, 598 or Z_STREAM_ERROR if the stream structure was inconsistent. In the success 599 case, the application may save the current current value of total_in which 600 indicates where valid compressed data was found. In the error case, the 601 application may repeatedly call inflateSync, providing more input each time, 602 until success or end of the input data. 603*/ 604 605extern int inflateReset OF((z_stream *strm)); 606/* 607 This function is equivalent to inflateEnd followed by inflateInit, 608 but does not free and reallocate all the internal decompression state. 609 The stream will keep attributes that may have been set by inflateInit2. 610 611 inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source 612 stream state was inconsistent (such as zalloc or state being NULL). 613*/ 614 615extern int inflateIncomp OF((z_stream *strm)); 616/* 617 This function adds the data at next_in (avail_in bytes) to the output 618 history without performing any output. There must be no pending output, 619 and the decompressor must be expecting to see the start of a block. 620 Calling this function is equivalent to decompressing a stored block 621 containing the data at next_in (except that the data is not output). 622*/ 623 624 /* checksum functions */ 625 626/* 627 This function is not related to compression but is exported 628 anyway because it might be useful in applications using the 629 compression library. 630*/ 631 632extern uLong adler32 OF((uLong adler, Bytef *buf, uInt len)); 633 634/* 635 Update a running Adler-32 checksum with the bytes buf[0..len-1] and 636 return the updated checksum. If buf is NULL, this function returns 637 the required initial value for the checksum. 638 An Adler-32 checksum is almost as reliable as a CRC32 but can be computed 639 much faster. Usage example: 640 641 uLong adler = adler32(0L, Z_NULL, 0); 642 643 while (read_buffer(buffer, length) != EOF) { 644 adler = adler32(adler, buffer, length); 645 } 646 if (adler != original_adler) error(); 647*/ 648 649#ifndef _Z_UTIL_H 650 struct internal_state {int dummy;}; /* hack for buggy compilers */ 651#endif 652 653#endif /* _ZLIB_H */ 654