![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to zlib.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / net|
Return to zlib.h CVS log | Up to [Apple XNU] / XNU / bsd / net |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * This file is derived from zlib.h and zconf.h from the zlib-1.0.4
24: * distribution by Jean-loup Gailly and Mark Adler, with some additions
25: * by Paul Mackerras to aid in implementing Deflate compression and
26: * decompression for PPP packets.
27: */
28:
29: /*
30: * ==FILEVERSION 971127==
31: *
32: * This marker is used by the Linux installation script to determine
33: * whether an up-to-date version of this file is already installed.
34: */
35:
36:
37: /* +++ zlib.h */
38: /* zlib.h -- interface of the 'zlib' general purpose compression library
39: version 1.0.4, Jul 24th, 1996.
40:
41: Copyright (C) 1995-1996 Jean-loup Gailly and Mark Adler
42:
43: This software is provided 'as-is', without any express or implied
44: warranty. In no event will the authors be held liable for any damages
45: arising from the use of this software.
46:
47: Permission is granted to anyone to use this software for any purpose,
48: including commercial applications, and to alter it and redistribute it
49: freely, subject to the following restrictions:
50:
51: 1. The origin of this software must not be misrepresented; you must not
52: claim that you wrote the original software. If you use this software
53: in a product, an acknowledgment in the product documentation would be
54: appreciated but is not required.
55: 2. Altered source versions must be plainly marked as such, and must not be
56: misrepresented as being the original software.
57: 3. This notice may not be removed or altered from any source distribution.
58:
59: Jean-loup Gailly Mark Adler
60: [email protected] [email protected]
61:
62:
63: The data format used by the zlib library is described by RFCs (Request for
64: Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
65: (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
66: */
67:
68: #ifndef _ZLIB_H
69: #define _ZLIB_H
70:
71: #ifdef __cplusplus
72: extern "C" {
73: #endif
74:
75:
76: /* +++ zconf.h */
77: /* zconf.h -- configuration of the zlib compression library
78: * Copyright (C) 1995-1996 Jean-loup Gailly.
79: * For conditions of distribution and use, see copyright notice in zlib.h
80: */
81:
82: /* From: zconf.h,v 1.20 1996/07/02 15:09:28 me Exp $ */
83:
84: #ifndef _ZCONF_H
85: #define _ZCONF_H
86:
87: /*
88: * If you *really* need a unique prefix for all types and library functions,
89: * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
90: */
91: #ifdef Z_PREFIX
92: # define deflateInit_ z_deflateInit_
93: # define deflate z_deflate
94: # define deflateEnd z_deflateEnd
95: # define inflateInit_ z_inflateInit_
96: # define inflate z_inflate
97: # define inflateEnd z_inflateEnd
98: # define deflateInit2_ z_deflateInit2_
99: # define deflateSetDictionary z_deflateSetDictionary
100: # define deflateCopy z_deflateCopy
101: # define deflateReset z_deflateReset
102: # define deflateParams z_deflateParams
103: # define inflateInit2_ z_inflateInit2_
104: # define inflateSetDictionary z_inflateSetDictionary
105: # define inflateSync z_inflateSync
106: # define inflateReset z_inflateReset
107: # define compress z_compress
108: # define uncompress z_uncompress
109: # define adler32 z_adler32
110: # define crc32 z_crc32
111: # define get_crc_table z_get_crc_table
112:
113: # define Byte z_Byte
114: # define uInt z_uInt
115: # define uLong z_uLong
116: # define Bytef z_Bytef
117: # define charf z_charf
118: # define intf z_intf
119: # define uIntf z_uIntf
120: # define uLongf z_uLongf
121: # define voidpf z_voidpf
122: # define voidp z_voidp
123: #endif
124:
125: #if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
126: # define WIN32
127: #endif
128: #if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386)
129: # ifndef __32BIT__
130: # define __32BIT__
131: # endif
132: #endif
133: #if defined(__MSDOS__) && !defined(MSDOS)
134: # define MSDOS
135: #endif
136:
137: /*
138: * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
139: * than 64k bytes at a time (needed on systems with 16-bit int).
140: */
141: #if defined(MSDOS) && !defined(__32BIT__)
142: # define MAXSEG_64K
143: #endif
144: #ifdef MSDOS
145: # define UNALIGNED_OK
146: #endif
147:
148: #if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC)
149: # define STDC
150: #endif
151: #if (defined(__STDC__) || defined(__cplusplus)) && !defined(STDC)
152: # define STDC
153: #endif
154:
155: #ifndef STDC
156: # ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
157: # define const
158: # endif
159: #endif
160:
161: /* Some Mac compilers merge all .h files incorrectly: */
162: #if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__)
163: # define NO_DUMMY_DECL
164: #endif
165:
166: /* Maximum value for memLevel in deflateInit2 */
167: #ifndef MAX_MEM_LEVEL
168: # ifdef MAXSEG_64K
169: # define MAX_MEM_LEVEL 8
170: # else
171: # define MAX_MEM_LEVEL 9
172: # endif
173: #endif
174:
175: /* Maximum value for windowBits in deflateInit2 and inflateInit2 */
176: #ifndef MAX_WBITS
177: # define MAX_WBITS 15 /* 32K LZ77 window */
178: #endif
179:
180: /* The memory requirements for deflate are (in bytes):
181: 1 << (windowBits+2) + 1 << (memLevel+9)
182: that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
183: plus a few kilobytes for small objects. For example, if you want to reduce
184: the default memory requirements from 256K to 128K, compile with
185: make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
186: Of course this will generally degrade compression (there's no free lunch).
187:
188: The memory requirements for inflate are (in bytes) 1 << windowBits
189: that is, 32K for windowBits=15 (default value) plus a few kilobytes
190: for small objects.
191: */
192:
193: /* Type declarations */
194:
195: #ifndef OF /* function prototypes */
196: # ifdef STDC
197: # define OF(args) args
198: # else
199: # define OF(args) ()
200: # endif
201: #endif
202:
203: /* The following definitions for FAR are needed only for MSDOS mixed
204: * model programming (small or medium model with some far allocations).
205: * This was tested only with MSC; for other MSDOS compilers you may have
206: * to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
207: * just define FAR to be empty.
208: */
209: #if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__)
210: /* MSC small or medium model */
211: # define SMALL_MEDIUM
212: # ifdef _MSC_VER
213: # define FAR __far
214: # else
215: # define FAR far
216: # endif
217: #endif
218: #if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
219: # ifndef __32BIT__
220: # define SMALL_MEDIUM
221: # define FAR __far
222: # endif
223: #endif
224: #ifndef FAR
225: # define FAR
226: #endif
227:
228: typedef unsigned char Byte; /* 8 bits */
229: typedef unsigned int uInt; /* 16 bits or more */
230: typedef unsigned long uLong; /* 32 bits or more */
231:
232: #if defined(__BORLANDC__) && defined(SMALL_MEDIUM)
233: /* Borland C/C++ ignores FAR inside typedef */
234: # define Bytef Byte FAR
235: #else
236: typedef Byte FAR Bytef;
237: #endif
238: typedef char FAR charf;
239: typedef int FAR intf;
240: typedef uInt FAR uIntf;
241: typedef uLong FAR uLongf;
242:
243: #if STDC
244: typedef void FAR *voidpf;
245: typedef void *voidp;
246: #else
247: typedef Byte FAR *voidpf;
248: typedef Byte *voidp;
249: #endif
250:
251:
252: /* Compile with -DZLIB_DLL for Windows DLL support */
253: #if (defined(_WINDOWS) || defined(WINDOWS)) && defined(ZLIB_DLL)
254: # include <windows.h>
255: # define EXPORT WINAPI
256: #else
257: # define EXPORT
258: #endif
259:
260: #endif /* _ZCONF_H */
261: /* --- zconf.h */
262:
263: #define ZLIB_VERSION "1.0.4P"
264:
265: /*
266: The 'zlib' compression library provides in-memory compression and
267: decompression functions, including integrity checks of the uncompressed
268: data. This version of the library supports only one compression method
269: (deflation) but other algorithms may be added later and will have the same
270: stream interface.
271:
272: For compression the application must provide the output buffer and
273: may optionally provide the input buffer for optimization. For decompression,
274: the application must provide the input buffer and may optionally provide
275: the output buffer for optimization.
276:
277: Compression can be done in a single step if the buffers are large
278: enough (for example if an input file is mmap'ed), or can be done by
279: repeated calls of the compression function. In the latter case, the
280: application must provide more input and/or consume the output
281: (providing more output space) before each call.
282:
283: The library does not install any signal handler. It is recommended to
284: add at least a handler for SIGSEGV when decompressing; the library checks
285: the consistency of the input data whenever possible but may go nuts
286: for some forms of corrupted input.
287: */
288:
289: typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
290: typedef void (*free_func) OF((voidpf opaque, voidpf address));
291:
292: struct internal_state;
293:
294: typedef struct z_stream_s {
295: Bytef *next_in; /* next input byte */
296: uInt avail_in; /* number of bytes available at next_in */
297: uLong total_in; /* total nb of input bytes read so far */
298:
299: Bytef *next_out; /* next output byte should be put there */
300: uInt avail_out; /* remaining free space at next_out */
301: uLong total_out; /* total nb of bytes output so far */
302:
303: char *msg; /* last error message, NULL if no error */
304: struct internal_state FAR *state; /* not visible by applications */
305:
306: alloc_func zalloc; /* used to allocate the internal state */
307: free_func zfree; /* used to free the internal state */
308: voidpf opaque; /* private data object passed to zalloc and zfree */
309:
310: int data_type; /* best guess about the data type: ascii or binary */
311: uLong adler; /* adler32 value of the uncompressed data */
312: uLong reserved; /* reserved for future use */
313: } z_stream;
314:
315: typedef z_stream FAR *z_streamp;
316:
317: /*
318: The application must update next_in and avail_in when avail_in has
319: dropped to zero. It must update next_out and avail_out when avail_out
320: has dropped to zero. The application must initialize zalloc, zfree and
321: opaque before calling the init function. All other fields are set by the
322: compression library and must not be updated by the application.
323:
324: The opaque value provided by the application will be passed as the first
325: parameter for calls of zalloc and zfree. This can be useful for custom
326: memory management. The compression library attaches no meaning to the
327: opaque value.
328:
329: zalloc must return Z_NULL if there is not enough memory for the object.
330: On 16-bit systems, the functions zalloc and zfree must be able to allocate
331: exactly 65536 bytes, but will not be required to allocate more than this
332: if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
333: pointers returned by zalloc for objects of exactly 65536 bytes *must*
334: have their offset normalized to zero. The default allocation function
335: provided by this library ensures this (see zutil.c). To reduce memory
336: requirements and avoid any allocation of 64K objects, at the expense of
337: compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
338:
339: The fields total_in and total_out can be used for statistics or
340: progress reports. After compression, total_in holds the total size of
341: the uncompressed data and may be saved for use in the decompressor
342: (particularly if the decompressor wants to decompress everything in
343: a single step).
344: */
345:
346: /* constants */
347:
348: #define Z_NO_FLUSH 0
349: #define Z_PARTIAL_FLUSH 1
350: #define Z_PACKET_FLUSH 2
351: #define Z_SYNC_FLUSH 3
352: #define Z_FULL_FLUSH 4
353: #define Z_FINISH 5
354: /* Allowed flush values; see deflate() below for details */
355:
356: #define Z_OK 0
357: #define Z_STREAM_END 1
358: #define Z_NEED_DICT 2
359: #define Z_ERRNO (-1)
360: #define Z_STREAM_ERROR (-2)
361: #define Z_DATA_ERROR (-3)
362: #define Z_MEM_ERROR (-4)
363: #define Z_BUF_ERROR (-5)
364: #define Z_VERSION_ERROR (-6)
365: /* Return codes for the compression/decompression functions. Negative
366: * values are errors, positive values are used for special but normal events.
367: */
368:
369: #define Z_NO_COMPRESSION 0
370: #define Z_BEST_SPEED 1
371: #define Z_BEST_COMPRESSION 9
372: #define Z_DEFAULT_COMPRESSION (-1)
373: /* compression levels */
374:
375: #define Z_FILTERED 1
376: #define Z_HUFFMAN_ONLY 2
377: #define Z_DEFAULT_STRATEGY 0
378: /* compression strategy; see deflateInit2() below for details */
379:
380: #define Z_BINARY 0
381: #define Z_ASCII 1
382: #define Z_UNKNOWN 2
383: /* Possible values of the data_type field */
384:
385: #define Z_DEFLATED 8
386: /* The deflate compression method (the only one supported in this version) */
387:
388: #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
389:
390: #define zlib_version zlibVersion()
391: /* for compatibility with versions < 1.0.2 */
392:
393: /* basic functions */
394:
395: extern const char * EXPORT zlibVersion OF((void));
396: /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
397: If the first character differs, the library code actually used is
398: not compatible with the zlib.h header file used by the application.
399: This check is automatically made by deflateInit and inflateInit.
400: */
401:
402: /*
403: extern int EXPORT deflateInit OF((z_streamp strm, int level));
404:
405: Initializes the internal stream state for compression. The fields
406: zalloc, zfree and opaque must be initialized before by the caller.
407: If zalloc and zfree are set to Z_NULL, deflateInit updates them to
408: use default allocation functions.
409:
410: The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
411: 1 gives best speed, 9 gives best compression, 0 gives no compression at
412: all (the input data is simply copied a block at a time).
413: Z_DEFAULT_COMPRESSION requests a default compromise between speed and
414: compression (currently equivalent to level 6).
415:
416: deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
417: enough memory, Z_STREAM_ERROR if level is not a valid compression level,
418: Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
419: with the version assumed by the caller (ZLIB_VERSION).
420: msg is set to null if there is no error message. deflateInit does not
421: perform any compression: this will be done by deflate().
422: */
423:
424:
425: extern int EXPORT deflate OF((z_streamp strm, int flush));
426: /*
427: Performs one or both of the following actions:
428:
429: - Compress more input starting at next_in and update next_in and avail_in
430: accordingly. If not all input can be processed (because there is not
431: enough room in the output buffer), next_in and avail_in are updated and
432: processing will resume at this point for the next call of deflate().
433:
434: - Provide more output starting at next_out and update next_out and avail_out
435: accordingly. This action is forced if the parameter flush is non zero.
436: Forcing flush frequently degrades the compression ratio, so this parameter
437: should be set only when necessary (in interactive applications).
438: Some output may be provided even if flush is not set.
439:
440: Before the call of deflate(), the application should ensure that at least
441: one of the actions is possible, by providing more input and/or consuming
442: more output, and updating avail_in or avail_out accordingly; avail_out
443: should never be zero before the call. The application can consume the
444: compressed output when it wants, for example when the output buffer is full
445: (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
446: and with zero avail_out, it must be called again after making room in the
447: output buffer because there might be more output pending.
448:
449: If the parameter flush is set to Z_PARTIAL_FLUSH, the current compression
450: block is terminated and flushed to the output buffer so that the
451: decompressor can get all input data available so far. For method 9, a future
452: variant on method 8, the current block will be flushed but not terminated.
453: Z_SYNC_FLUSH has the same effect as partial flush except that the compressed
454: output is byte aligned (the compressor can clear its internal bit buffer)
455: and the current block is always terminated; this can be useful if the
456: compressor has to be restarted from scratch after an interruption (in which
457: case the internal state of the compressor may be lost).
458: If flush is set to Z_FULL_FLUSH, the compression block is terminated, a
459: special marker is output and the compression dictionary is discarded; this
460: is useful to allow the decompressor to synchronize if one compressed block
461: has been damaged (see inflateSync below). Flushing degrades compression and
462: so should be used only when necessary. Using Z_FULL_FLUSH too often can
463: seriously degrade the compression. If deflate returns with avail_out == 0,
464: this function must be called again with the same value of the flush
465: parameter and more output space (updated avail_out), until the flush is
466: complete (deflate returns with non-zero avail_out).
467:
468: If the parameter flush is set to Z_PACKET_FLUSH, the compression
469: block is terminated, and a zero-length stored block is output,
470: omitting the length bytes (the effect of this is that the 3-bit type
471: code 000 for a stored block is output, and the output is then
472: byte-aligned). This is designed for use at the end of a PPP packet.
473:
474: If the parameter flush is set to Z_FINISH, pending input is processed,
475: pending output is flushed and deflate returns with Z_STREAM_END if there
476: was enough output space; if deflate returns with Z_OK, this function must be
477: called again with Z_FINISH and more output space (updated avail_out) but no
478: more input data, until it returns with Z_STREAM_END or an error. After
479: deflate has returned Z_STREAM_END, the only possible operations on the
480: stream are deflateReset or deflateEnd.
481:
482: Z_FINISH can be used immediately after deflateInit if all the compression
483: is to be done in a single step. In this case, avail_out must be at least
484: 0.1% larger than avail_in plus 12 bytes. If deflate does not return
485: Z_STREAM_END, then it must be called again as described above.
486:
487: deflate() may update data_type if it can make a good guess about
488: the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
489: binary. This field is only for information purposes and does not affect
490: the compression algorithm in any manner.
491:
492: deflate() returns Z_OK if some progress has been made (more input
493: processed or more output produced), Z_STREAM_END if all input has been
494: consumed and all output has been produced (only when flush is set to
495: Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
496: if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible.
497: */
498:
499:
500: extern int EXPORT deflateEnd OF((z_streamp strm));
501: /*
502: All dynamically allocated data structures for this stream are freed.
503: This function discards any unprocessed input and does not flush any
504: pending output.
505:
506: deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
507: stream state was inconsistent, Z_DATA_ERROR if the stream was freed
508: prematurely (some input or output was discarded). In the error case,
509: msg may be set but then points to a static string (which must not be
510: deallocated).
511: */
512:
513:
514: /*
515: extern int EXPORT inflateInit OF((z_streamp strm));
516:
517: Initializes the internal stream state for decompression. The fields
518: zalloc, zfree and opaque must be initialized before by the caller. If
519: zalloc and zfree are set to Z_NULL, inflateInit updates them to use default
520: allocation functions.
521:
522: inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
523: enough memory, Z_VERSION_ERROR if the zlib library version is incompatible
524: with the version assumed by the caller. msg is set to null if there is no
525: error message. inflateInit does not perform any decompression: this will be
526: done by inflate().
527: */
528:
529: #if defined(__FreeBSD__) && (defined(KERNEL) || defined(_KERNEL))
530: #define inflate inflate_ppp /* FreeBSD already has an inflate :-( */
531: #endif
532:
533: extern int EXPORT inflate OF((z_streamp strm, int flush));
534: /*
535: Performs one or both of the following actions:
536:
537: - Decompress more input starting at next_in and update next_in and avail_in
538: accordingly. If not all input can be processed (because there is not
539: enough room in the output buffer), next_in is updated and processing
540: will resume at this point for the next call of inflate().
541:
542: - Provide more output starting at next_out and update next_out and avail_out
543: accordingly. inflate() provides as much output as possible, until there
544: is no more input data or no more space in the output buffer (see below
545: about the flush parameter).
546:
547: Before the call of inflate(), the application should ensure that at least
548: one of the actions is possible, by providing more input and/or consuming
549: more output, and updating the next_* and avail_* values accordingly.
550: The application can consume the uncompressed output when it wants, for
551: example when the output buffer is full (avail_out == 0), or after each
552: call of inflate(). If inflate returns Z_OK and with zero avail_out, it
553: must be called again after making room in the output buffer because there
554: might be more output pending.
555:
556: If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH,
557: inflate flushes as much output as possible to the output buffer. The
558: flushing behavior of inflate is not specified for values of the flush
559: parameter other than Z_PARTIAL_FLUSH, Z_PACKET_FLUSH or Z_FINISH, but the
560: current implementation actually flushes as much output as possible
561: anyway. For Z_PACKET_FLUSH, inflate checks that once all the input data
562: has been consumed, it is expecting to see the length field of a stored
563: block; if not, it returns Z_DATA_ERROR.
564:
565: inflate() should normally be called until it returns Z_STREAM_END or an
566: error. However if all decompression is to be performed in a single step
567: (a single call of inflate), the parameter flush should be set to
568: Z_FINISH. In this case all pending input is processed and all pending
569: output is flushed; avail_out must be large enough to hold all the
570: uncompressed data. (The size of the uncompressed data may have been saved
571: by the compressor for this purpose.) The next operation on this stream must
572: be inflateEnd to deallocate the decompression state. The use of Z_FINISH
573: is never required, but can be used to inform inflate that a faster routine
574: may be used for the single inflate() call.
575:
576: inflate() returns Z_OK if some progress has been made (more input
577: processed or more output produced), Z_STREAM_END if the end of the
578: compressed data has been reached and all uncompressed output has been
579: produced, Z_NEED_DICT if a preset dictionary is needed at this point (see
580: inflateSetDictionary below), Z_DATA_ERROR if the input data was corrupted,
581: Z_STREAM_ERROR if the stream structure was inconsistent (for example if
582: next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
583: Z_BUF_ERROR if no progress is possible or if there was not enough room in
584: the output buffer when Z_FINISH is used. In the Z_DATA_ERROR case, the
585: application may then call inflateSync to look for a good compression block.
586: In the Z_NEED_DICT case, strm->adler is set to the Adler32 value of the
587: dictionary chosen by the compressor.
588: */
589:
590:
591: extern int EXPORT inflateEnd OF((z_streamp strm));
592: /*
593: All dynamically allocated data structures for this stream are freed.
594: This function discards any unprocessed input and does not flush any
595: pending output.
596:
597: inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
598: was inconsistent. In the error case, msg may be set but then points to a
599: static string (which must not be deallocated).
600: */
601:
602: /* Advanced functions */
603:
604: /*
605: The following functions are needed only in some special applications.
606: */
607:
608: /*
609: extern int EXPORT deflateInit2 OF((z_streamp strm,
610: int level,
611: int method,
612: int windowBits,
613: int memLevel,
614: int strategy));
615:
616: This is another version of deflateInit with more compression options. The
617: fields next_in, zalloc, zfree and opaque must be initialized before by
618: the caller.
619:
620: The method parameter is the compression method. It must be Z_DEFLATED in
621: this version of the library. (Method 9 will allow a 64K history buffer and
622: partial block flushes.)
623:
624: The windowBits parameter is the base two logarithm of the window size
625: (the size of the history buffer). It should be in the range 8..15 for this
626: version of the library (the value 16 will be allowed for method 9). Larger
627: values of this parameter result in better compression at the expense of
628: memory usage. The default value is 15 if deflateInit is used instead.
629:
630: The memLevel parameter specifies how much memory should be allocated
631: for the internal compression state. memLevel=1 uses minimum memory but
632: is slow and reduces compression ratio; memLevel=9 uses maximum memory
633: for optimal speed. The default value is 8. See zconf.h for total memory
634: usage as a function of windowBits and memLevel.
635:
636: The strategy parameter is used to tune the compression algorithm. Use the
637: value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
638: filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
639: string match). Filtered data consists mostly of small values with a
640: somewhat random distribution. In this case, the compression algorithm is
641: tuned to compress them better. The effect of Z_FILTERED is to force more
642: Huffman coding and less string matching; it is somewhat intermediate
643: between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
644: the compression ratio but not the correctness of the compressed output even
645: if it is not set appropriately.
646:
647: If next_in is not null, the library will use this buffer to hold also
648: some history information; the buffer must either hold the entire input
649: data, or have at least 1<<(windowBits+1) bytes and be writable. If next_in
650: is null, the library will allocate its own history buffer (and leave next_in
651: null). next_out need not be provided here but must be provided by the
652: application for the next call of deflate().
653:
654: If the history buffer is provided by the application, next_in must
655: must never be changed by the application since the compressor maintains
656: information inside this buffer from call to call; the application
657: must provide more input only by increasing avail_in. next_in is always
658: reset by the library in this case.
659:
660: deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
661: not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
662: an invalid method). msg is set to null if there is no error message.
663: deflateInit2 does not perform any compression: this will be done by
664: deflate().
665: */
666:
667: extern int EXPORT deflateSetDictionary OF((z_streamp strm,
668: const Bytef *dictionary,
669: uInt dictLength));
670: /*
671: Initializes the compression dictionary (history buffer) from the given
672: byte sequence without producing any compressed output. This function must
673: be called immediately after deflateInit or deflateInit2, before any call
674: of deflate. The compressor and decompressor must use exactly the same
675: dictionary (see inflateSetDictionary).
676: The dictionary should consist of strings (byte sequences) that are likely
677: to be encountered later in the data to be compressed, with the most commonly
678: used strings preferably put towards the end of the dictionary. Using a
679: dictionary is most useful when the data to be compressed is short and
680: can be predicted with good accuracy; the data can then be compressed better
681: than with the default empty dictionary. In this version of the library,
682: only the last 32K bytes of the dictionary are used.
683: Upon return of this function, strm->adler is set to the Adler32 value
684: of the dictionary; the decompressor may later use this value to determine
685: which dictionary has been used by the compressor. (The Adler32 value
686: applies to the whole dictionary even if only a subset of the dictionary is
687: actually used by the compressor.)
688:
689: deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
690: parameter is invalid (such as NULL dictionary) or the stream state
691: is inconsistent (for example if deflate has already been called for this
692: stream). deflateSetDictionary does not perform any compression: this will
693: be done by deflate().
694: */
695:
696: extern int EXPORT deflateCopy OF((z_streamp dest,
697: z_streamp source));
698: /*
699: Sets the destination stream as a complete copy of the source stream. If
700: the source stream is using an application-supplied history buffer, a new
701: buffer is allocated for the destination stream. The compressed output
702: buffer is always application-supplied. It's the responsibility of the
703: application to provide the correct values of next_out and avail_out for the
704: next call of deflate.
705:
706: This function can be useful when several compression strategies will be
707: tried, for example when there are several ways of pre-processing the input
708: data with a filter. The streams that will be discarded should then be freed
709: by calling deflateEnd. Note that deflateCopy duplicates the internal
710: compression state which can be quite large, so this strategy is slow and
711: can consume lots of memory.
712:
713: deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
714: enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
715: (such as zalloc being NULL). msg is left unchanged in both source and
716: destination.
717: */
718:
719: extern int EXPORT deflateReset OF((z_streamp strm));
720: /*
721: This function is equivalent to deflateEnd followed by deflateInit,
722: but does not free and reallocate all the internal compression state.
723: The stream will keep the same compression level and any other attributes
724: that may have been set by deflateInit2.
725:
726: deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
727: stream state was inconsistent (such as zalloc or state being NULL).
728: */
729:
730: extern int EXPORT deflateParams OF((z_streamp strm, int level, int strategy));
731: /*
732: Dynamically update the compression level and compression strategy.
733: This can be used to switch between compression and straight copy of
734: the input data, or to switch to a different kind of input data requiring
735: a different strategy. If the compression level is changed, the input
736: available so far is compressed with the old level (and may be flushed);
737: the new level will take effect only at the next call of deflate().
738:
739: Before the call of deflateParams, the stream state must be set as for
740: a call of deflate(), since the currently available input may have to
741: be compressed and flushed. In particular, strm->avail_out must be non-zero.
742:
743: deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
744: stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
745: if strm->avail_out was zero.
746: */
747:
748: extern int EXPORT deflateOutputPending OF((z_streamp strm));
749: /*
750: Returns the number of bytes of output which are immediately
751: available from the compressor (i.e. without any further input
752: or flush).
753: */
754:
755: /*
756: extern int EXPORT inflateInit2 OF((z_streamp strm,
757: int windowBits));
758:
759: This is another version of inflateInit with more compression options. The
760: fields next_out, zalloc, zfree and opaque must be initialized before by
761: the caller.
762:
763: The windowBits parameter is the base two logarithm of the maximum window
764: size (the size of the history buffer). It should be in the range 8..15 for
765: this version of the library (the value 16 will be allowed soon). The
766: default value is 15 if inflateInit is used instead. If a compressed stream
767: with a larger window size is given as input, inflate() will return with
768: the error code Z_DATA_ERROR instead of trying to allocate a larger window.
769:
770: If next_out is not null, the library will use this buffer for the history
771: buffer; the buffer must either be large enough to hold the entire output
772: data, or have at least 1<<windowBits bytes. If next_out is null, the
773: library will allocate its own buffer (and leave next_out null). next_in
774: need not be provided here but must be provided by the application for the
775: next call of inflate().
776:
777: If the history buffer is provided by the application, next_out must
778: never be changed by the application since the decompressor maintains
779: history information inside this buffer from call to call; the application
780: can only reset next_out to the beginning of the history buffer when
781: avail_out is zero and all output has been consumed.
782:
783: inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
784: not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
785: windowBits < 8). msg is set to null if there is no error message.
786: inflateInit2 does not perform any decompression: this will be done by
787: inflate().
788: */
789:
790: extern int EXPORT inflateSetDictionary OF((z_streamp strm,
791: const Bytef *dictionary,
792: uInt dictLength));
793: /*
794: Initializes the decompression dictionary (history buffer) from the given
795: uncompressed byte sequence. This function must be called immediately after
796: a call of inflate if this call returned Z_NEED_DICT. The dictionary chosen
797: by the compressor can be determined from the Adler32 value returned by this
798: call of inflate. The compressor and decompressor must use exactly the same
799: dictionary (see deflateSetDictionary).
800:
801: inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
802: parameter is invalid (such as NULL dictionary) or the stream state is
803: inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
804: expected one (incorrect Adler32 value). inflateSetDictionary does not
805: perform any decompression: this will be done by subsequent calls of
806: inflate().
807: */
808:
809: extern int EXPORT inflateSync OF((z_streamp strm));
810: /*
811: Skips invalid compressed data until the special marker (see deflate()
812: above) can be found, or until all available input is skipped. No output
813: is provided.
814:
815: inflateSync returns Z_OK if the special marker has been found, Z_BUF_ERROR
816: if no more input was provided, Z_DATA_ERROR if no marker has been found,
817: or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
818: case, the application may save the current current value of total_in which
819: indicates where valid compressed data was found. In the error case, the
820: application may repeatedly call inflateSync, providing more input each time,
821: until success or end of the input data.
822: */
823:
824: extern int EXPORT inflateReset OF((z_streamp strm));
825: /*
826: This function is equivalent to inflateEnd followed by inflateInit,
827: but does not free and reallocate all the internal decompression state.
828: The stream will keep attributes that may have been set by inflateInit2.
829:
830: inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
831: stream state was inconsistent (such as zalloc or state being NULL).
832: */
833:
834: extern int inflateIncomp OF((z_stream *strm));
835: /*
836: This function adds the data at next_in (avail_in bytes) to the output
837: history without performing any output. There must be no pending output,
838: and the decompressor must be expecting to see the start of a block.
839: Calling this function is equivalent to decompressing a stored block
840: containing the data at next_in (except that the data is not output).
841: */
842:
843: /* utility functions */
844:
845: /*
846: The following utility functions are implemented on top of the
847: basic stream-oriented functions. To simplify the interface, some
848: default options are assumed (compression level, window size,
849: standard memory allocation functions). The source code of these
850: utility functions can easily be modified if you need special options.
851: */
852:
853: extern int EXPORT compress OF((Bytef *dest, uLongf *destLen,
854: const Bytef *source, uLong sourceLen));
855: /*
856: Compresses the source buffer into the destination buffer. sourceLen is
857: the byte length of the source buffer. Upon entry, destLen is the total
858: size of the destination buffer, which must be at least 0.1% larger than
859: sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
860: compressed buffer.
861: This function can be used to compress a whole file at once if the
862: input file is mmap'ed.
863: compress returns Z_OK if success, Z_MEM_ERROR if there was not
864: enough memory, Z_BUF_ERROR if there was not enough room in the output
865: buffer.
866: */
867:
868: extern int EXPORT uncompress OF((Bytef *dest, uLongf *destLen,
869: const Bytef *source, uLong sourceLen));
870: /*
871: Decompresses the source buffer into the destination buffer. sourceLen is
872: the byte length of the source buffer. Upon entry, destLen is the total
873: size of the destination buffer, which must be large enough to hold the
874: entire uncompressed data. (The size of the uncompressed data must have
875: been saved previously by the compressor and transmitted to the decompressor
876: by some mechanism outside the scope of this compression library.)
877: Upon exit, destLen is the actual size of the compressed buffer.
878: This function can be used to decompress a whole file at once if the
879: input file is mmap'ed.
880:
881: uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
882: enough memory, Z_BUF_ERROR if there was not enough room in the output
883: buffer, or Z_DATA_ERROR if the input data was corrupted.
884: */
885:
886:
887: typedef voidp gzFile;
888:
889: extern gzFile EXPORT gzopen OF((const char *path, const char *mode));
890: /*
891: Opens a gzip (.gz) file for reading or writing. The mode parameter
892: is as in fopen ("rb" or "wb") but can also include a compression level
893: ("wb9"). gzopen can be used to read a file which is not in gzip format;
894: in this case gzread will directly read from the file without decompression.
895: gzopen returns NULL if the file could not be opened or if there was
896: insufficient memory to allocate the (de)compression state; errno
897: can be checked to distinguish the two cases (if errno is zero, the
898: zlib error is Z_MEM_ERROR).
899: */
900:
901: extern gzFile EXPORT gzdopen OF((int fd, const char *mode));
902: /*
903: gzdopen() associates a gzFile with the file descriptor fd. File
904: descriptors are obtained from calls like open, dup, creat, pipe or
905: fileno (in the file has been previously opened with fopen).
906: The mode parameter is as in gzopen.
907: The next call of gzclose on the returned gzFile will also close the
908: file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
909: descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
910: gzdopen returns NULL if there was insufficient memory to allocate
911: the (de)compression state.
912: */
913:
914: extern int EXPORT gzread OF((gzFile file, voidp buf, unsigned len));
915: /*
916: Reads the given number of uncompressed bytes from the compressed file.
917: If the input file was not in gzip format, gzread copies the given number
918: of bytes into the buffer.
919: gzread returns the number of uncompressed bytes actually read (0 for
920: end of file, -1 for error). */
921:
922: extern int EXPORT gzwrite OF((gzFile file, const voidp buf, unsigned len));
923: /*
924: Writes the given number of uncompressed bytes into the compressed file.
925: gzwrite returns the number of uncompressed bytes actually written
926: (0 in case of error).
927: */
928:
929: extern int EXPORT gzflush OF((gzFile file, int flush));
930: /*
931: Flushes all pending output into the compressed file. The parameter
932: flush is as in the deflate() function. The return value is the zlib
933: error number (see function gzerror below). gzflush returns Z_OK if
934: the flush parameter is Z_FINISH and all output could be flushed.
935: gzflush should be called only when strictly necessary because it can
936: degrade compression.
937: */
938:
939: extern int EXPORT gzclose OF((gzFile file));
940: /*
941: Flushes all pending output if necessary, closes the compressed file
942: and deallocates all the (de)compression state. The return value is the zlib
943: error number (see function gzerror below).
944: */
945:
946: extern const char * EXPORT gzerror OF((gzFile file, int *errnum));
947: /*
948: Returns the error message for the last error which occurred on the
949: given compressed file. errnum is set to zlib error number. If an
950: error occurred in the file system and not in the compression library,
951: errnum is set to Z_ERRNO and the application may consult errno
952: to get the exact error code.
953: */
954:
955: /* checksum functions */
956:
957: /*
958: These functions are not related to compression but are exported
959: anyway because they might be useful in applications using the
960: compression library.
961: */
962:
963: extern uLong EXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
964:
965: /*
966: Update a running Adler-32 checksum with the bytes buf[0..len-1] and
967: return the updated checksum. If buf is NULL, this function returns
968: the required initial value for the checksum.
969: An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
970: much faster. Usage example:
971:
972: uLong adler = adler32(0L, Z_NULL, 0);
973:
974: while (read_buffer(buffer, length) != EOF) {
975: adler = adler32(adler, buffer, length);
976: }
977: if (adler != original_adler) error();
978: */
979:
980: extern uLong EXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
981: /*
982: Update a running crc with the bytes buf[0..len-1] and return the updated
983: crc. If buf is NULL, this function returns the required initial value
984: for the crc. Pre- and post-conditioning (one's complement) is performed
985: within this function so it shouldn't be done by the application.
986: Usage example:
987:
988: uLong crc = crc32(0L, Z_NULL, 0);
989:
990: while (read_buffer(buffer, length) != EOF) {
991: crc = crc32(crc, buffer, length);
992: }
993: if (crc != original_crc) error();
994: */
995:
996:
997: /* various hacks, don't look :) */
998:
999: /* deflateInit and inflateInit are macros to allow checking the zlib version
1000: * and the compiler's view of z_stream:
1001: */
1002: extern int EXPORT deflateInit_ OF((z_streamp strm, int level,
1003: const char *version, int stream_size));
1004: extern int EXPORT inflateInit_ OF((z_streamp strm,
1005: const char *version, int stream_size));
1006: extern int EXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
1007: int windowBits, int memLevel, int strategy,
1008: const char *version, int stream_size));
1009: extern int EXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
1010: const char *version, int stream_size));
1011: #define deflateInit(strm, level) \
1012: deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
1013: #define inflateInit(strm) \
1014: inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))
1015: #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
1016: deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
1017: (strategy), ZLIB_VERSION, sizeof(z_stream))
1018: #define inflateInit2(strm, windowBits) \
1019: inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
1020:
1021: #if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
1022: struct internal_state {int dummy;}; /* hack for buggy compilers */
1023: #endif
1024:
1025: uLongf *get_crc_table OF((void)); /* can be used by asm versions of crc32() */
1026:
1027: #ifdef __cplusplus
1028: }
1029: #endif
1030:
1031: #endif /* _ZLIB_H */
1032: /* --- zlib.h */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.