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