]>
Commit | Line | Data |
---|---|---|
4a5b6a35 | 1 | /* |
dce3d797 | 2 | * This file is derived from zlib.h and zconf.h from the zlib-1.2.3 |
4a5b6a35 WD |
3 | * distribution by Jean-loup Gailly and Mark Adler, with some additions |
4 | * by Paul Mackerras to aid in implementing Deflate compression and | |
5 | * decompression for PPP packets. | |
6 | */ | |
7 | ||
dce3d797 GC |
8 | /* |
9 | * ==FILEVERSION 960122== | |
10 | * | |
11 | * This marker is used by the Linux installation script to determine | |
12 | * whether an up-to-date version of this file is already installed. | |
13 | */ | |
4a5b6a35 WD |
14 | |
15 | /* zlib.h -- interface of the 'zlib' general purpose compression library | |
dce3d797 | 16 | version 1.2.3, July 18th, 2005 |
4a5b6a35 | 17 | |
dce3d797 | 18 | Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler |
4a5b6a35 WD |
19 | |
20 | This software is provided 'as-is', without any express or implied | |
21 | warranty. In no event will the authors be held liable for any damages | |
22 | arising from the use of this software. | |
23 | ||
24 | Permission is granted to anyone to use this software for any purpose, | |
25 | including commercial applications, and to alter it and redistribute it | |
26 | freely, subject to the following restrictions: | |
27 | ||
28 | 1. The origin of this software must not be misrepresented; you must not | |
29 | claim that you wrote the original software. If you use this software | |
30 | in a product, an acknowledgment in the product documentation would be | |
31 | appreciated but is not required. | |
32 | 2. Altered source versions must be plainly marked as such, and must not be | |
33 | misrepresented as being the original software. | |
34 | 3. This notice may not be removed or altered from any source distribution. | |
35 | ||
36 | Jean-loup Gailly Mark Adler | |
dce3d797 GC |
37 | jloup@gzip.org madler@alumni.caltech.edu |
38 | ||
b201171f | 39 | |
dce3d797 GC |
40 | The data format used by the zlib library is described by RFCs (Request for |
41 | Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt | |
42 | (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). | |
43 | */ | |
44 | ||
45 | #ifndef ZLIB_H | |
46 | #define ZLIB_H | |
47 | ||
48 | #ifdef __cplusplus | |
49 | extern "C" { | |
50 | #endif | |
4a5b6a35 | 51 | |
dce3d797 GC |
52 | #define ZLIB_VERSION "1.2.3" |
53 | #define ZLIB_VERNUM 0x1230 | |
4a5b6a35 | 54 | |
dce3d797 | 55 | /* #include "zconf.h" */ /* included directly here */ |
4a5b6a35 | 56 | /* zconf.h -- configuration of the zlib compression library |
dce3d797 | 57 | * Copyright (C) 1995-2005 Jean-loup Gailly. |
4a5b6a35 WD |
58 | * For conditions of distribution and use, see copyright notice in zlib.h |
59 | */ | |
60 | ||
dce3d797 | 61 | /* Begin of new zconf.h */ |
4a5b6a35 | 62 | /* |
dce3d797 GC |
63 | * If you *really* need a unique prefix for all types and library functions, |
64 | * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. | |
4a5b6a35 | 65 | */ |
dce3d797 GC |
66 | #ifdef Z_PREFIX |
67 | # define deflateInit_ z_deflateInit_ | |
68 | # define deflate z_deflate | |
69 | # define deflateEnd z_deflateEnd | |
70 | # define inflateInit_ z_inflateInit_ | |
71 | # define inflate z_inflate | |
72 | # define inflateEnd z_inflateEnd | |
73 | # define deflateInit2_ z_deflateInit2_ | |
74 | # define deflateSetDictionary z_deflateSetDictionary | |
75 | # define deflateCopy z_deflateCopy | |
76 | # define deflateReset z_deflateReset | |
77 | # define deflateParams z_deflateParams | |
78 | # define deflateBound z_deflateBound | |
79 | # define deflatePrime z_deflatePrime | |
80 | # define inflateInit2_ z_inflateInit2_ | |
81 | # define inflateSetDictionary z_inflateSetDictionary | |
82 | # define inflateSync z_inflateSync | |
83 | # define inflateSyncPoint z_inflateSyncPoint | |
84 | # define inflateCopy z_inflateCopy | |
85 | # define inflateReset z_inflateReset | |
86 | # define inflateBack z_inflateBack | |
87 | # define inflateBackEnd z_inflateBackEnd | |
88 | # define compress z_compress | |
89 | # define compress2 z_compress2 | |
90 | # define compressBound z_compressBound | |
91 | # define uncompress z_uncompress | |
92 | # define adler32 z_adler32 | |
93 | # define crc32 z_crc32 | |
94 | # define get_crc_table z_get_crc_table | |
95 | # define zError z_zError | |
96 | ||
97 | # define alloc_func z_alloc_func | |
98 | # define free_func z_free_func | |
99 | # define in_func z_in_func | |
100 | # define out_func z_out_func | |
101 | # define Byte z_Byte | |
102 | # define uInt z_uInt | |
103 | # define uLong z_uLong | |
104 | # define Bytef z_Bytef | |
105 | # define charf z_charf | |
106 | # define intf z_intf | |
107 | # define uIntf z_uIntf | |
108 | # define uLongf z_uLongf | |
109 | # define voidpf z_voidpf | |
110 | # define voidp z_voidp | |
111 | #endif | |
112 | ||
113 | #if defined(__MSDOS__) && !defined(MSDOS) | |
114 | # define MSDOS | |
115 | #endif | |
116 | #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) | |
117 | # define OS2 | |
118 | #endif | |
119 | #if defined(_WINDOWS) && !defined(WINDOWS) | |
120 | # define WINDOWS | |
121 | #endif | |
122 | #if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) | |
123 | # ifndef WIN32 | |
124 | # define WIN32 | |
125 | # endif | |
126 | #endif | |
127 | #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) | |
128 | # if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) | |
129 | # ifndef SYS16BIT | |
130 | # define SYS16BIT | |
131 | # endif | |
132 | # endif | |
133 | #endif | |
4a5b6a35 WD |
134 | |
135 | /* | |
136 | * Compile with -DMAXSEG_64K if the alloc function cannot allocate more | |
137 | * than 64k bytes at a time (needed on systems with 16-bit int). | |
4a5b6a35 | 138 | */ |
dce3d797 GC |
139 | #ifdef SYS16BIT |
140 | # define MAXSEG_64K | |
141 | #endif | |
142 | #ifdef MSDOS | |
143 | # define UNALIGNED_OK | |
144 | #endif | |
b201171f | 145 | |
dce3d797 GC |
146 | #ifdef __STDC_VERSION__ |
147 | # ifndef STDC | |
f33b325a | 148 | # define STDC |
b201171f | 149 | # endif |
dce3d797 GC |
150 | # if __STDC_VERSION__ >= 199901L |
151 | # ifndef STDC99 | |
152 | # define STDC99 | |
153 | # endif | |
154 | # endif | |
155 | #endif | |
156 | #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) | |
157 | # define STDC | |
158 | #endif | |
159 | #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) | |
160 | # define STDC | |
161 | #endif | |
162 | #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) | |
163 | # define STDC | |
164 | #endif | |
165 | #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) | |
166 | # define STDC | |
167 | #endif | |
168 | ||
169 | #if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ | |
170 | # define STDC | |
171 | #endif | |
172 | ||
173 | #ifndef STDC | |
174 | # ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ | |
175 | # define const /* note: need a more gentle solution here */ | |
176 | # endif | |
4a5b6a35 WD |
177 | #endif |
178 | ||
dce3d797 GC |
179 | /* Some Mac compilers merge all .h files incorrectly: */ |
180 | #if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) | |
181 | # define NO_DUMMY_DECL | |
4a5b6a35 WD |
182 | #endif |
183 | ||
184 | /* Maximum value for memLevel in deflateInit2 */ | |
185 | #ifndef MAX_MEM_LEVEL | |
186 | # ifdef MAXSEG_64K | |
187 | # define MAX_MEM_LEVEL 8 | |
188 | # else | |
189 | # define MAX_MEM_LEVEL 9 | |
190 | # endif | |
191 | #endif | |
192 | ||
dce3d797 GC |
193 | /* Maximum value for windowBits in deflateInit2 and inflateInit2. |
194 | * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files | |
195 | * created by gzip. (Files created by minigzip can still be extracted by | |
196 | * gzip.) | |
197 | */ | |
4a5b6a35 WD |
198 | #ifndef MAX_WBITS |
199 | # define MAX_WBITS 15 /* 32K LZ77 window */ | |
200 | #endif | |
201 | ||
202 | /* The memory requirements for deflate are (in bytes): | |
dce3d797 | 203 | (1 << (windowBits+2)) + (1 << (memLevel+9)) |
4a5b6a35 WD |
204 | that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) |
205 | plus a few kilobytes for small objects. For example, if you want to reduce | |
206 | the default memory requirements from 256K to 128K, compile with | |
207 | make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" | |
208 | Of course this will generally degrade compression (there's no free lunch). | |
209 | ||
210 | The memory requirements for inflate are (in bytes) 1 << windowBits | |
211 | that is, 32K for windowBits=15 (default value) plus a few kilobytes | |
212 | for small objects. | |
213 | */ | |
214 | ||
dce3d797 | 215 | /* Type declarations */ |
4a5b6a35 WD |
216 | |
217 | #ifndef OF /* function prototypes */ | |
218 | # ifdef STDC | |
219 | # define OF(args) args | |
220 | # else | |
221 | # define OF(args) () | |
222 | # endif | |
223 | #endif | |
224 | ||
dce3d797 GC |
225 | /* The following definitions for FAR are needed only for MSDOS mixed |
226 | * model programming (small or medium model with some far allocations). | |
227 | * This was tested only with MSC; for other MSDOS compilers you may have | |
228 | * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, | |
229 | * just define FAR to be empty. | |
230 | */ | |
231 | #ifdef SYS16BIT | |
232 | # if defined(M_I86SM) || defined(M_I86MM) | |
233 | /* MSC small or medium model */ | |
234 | # define SMALL_MEDIUM | |
235 | # ifdef _MSC_VER | |
236 | # define FAR _far | |
237 | # else | |
238 | # define FAR far | |
239 | # endif | |
240 | # endif | |
241 | # if (defined(__SMALL__) || defined(__MEDIUM__)) | |
242 | /* Turbo C small or medium model */ | |
243 | # define SMALL_MEDIUM | |
244 | # ifdef __BORLANDC__ | |
245 | # define FAR _far | |
246 | # else | |
247 | # define FAR far | |
248 | # endif | |
249 | # endif | |
250 | #endif | |
251 | ||
252 | #if defined(WINDOWS) || defined(WIN32) | |
253 | /* If building or using zlib as a DLL, define ZLIB_DLL. | |
254 | * This is not mandatory, but it offers a little performance increase. | |
255 | */ | |
256 | # ifdef ZLIB_DLL | |
257 | # if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) | |
258 | # ifdef ZLIB_INTERNAL | |
259 | # define ZEXTERN extern __declspec(dllexport) | |
260 | # else | |
261 | # define ZEXTERN extern __declspec(dllimport) | |
262 | # endif | |
263 | # endif | |
264 | # endif /* ZLIB_DLL */ | |
265 | /* If building or using zlib with the WINAPI/WINAPIV calling convention, | |
266 | * define ZLIB_WINAPI. | |
267 | * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. | |
268 | */ | |
269 | # ifdef ZLIB_WINAPI | |
270 | # ifdef FAR | |
271 | # undef FAR | |
272 | # endif | |
273 | # include <windows.h> | |
274 | /* No need for _export, use ZLIB.DEF instead. */ | |
275 | /* For complete Windows compatibility, use WINAPI, not __stdcall. */ | |
276 | # define ZEXPORT WINAPI | |
277 | # ifdef WIN32 | |
278 | # define ZEXPORTVA WINAPIV | |
279 | # else | |
280 | # define ZEXPORTVA FAR CDECL | |
281 | # endif | |
282 | # endif | |
283 | #endif | |
284 | ||
285 | #if defined (__BEOS__) | |
286 | # ifdef ZLIB_DLL | |
287 | # ifdef ZLIB_INTERNAL | |
288 | # define ZEXPORT __declspec(dllexport) | |
289 | # define ZEXPORTVA __declspec(dllexport) | |
290 | # else | |
291 | # define ZEXPORT __declspec(dllimport) | |
292 | # define ZEXPORTVA __declspec(dllimport) | |
293 | # endif | |
294 | # endif | |
295 | #endif | |
296 | ||
297 | #ifndef ZEXTERN | |
298 | # define ZEXTERN extern | |
299 | #endif | |
300 | #ifndef ZEXPORT | |
301 | # define ZEXPORT | |
302 | #endif | |
303 | #ifndef ZEXPORTVA | |
304 | # define ZEXPORTVA | |
305 | #endif | |
306 | ||
307 | #ifndef FAR | |
308 | # define FAR | |
309 | #endif | |
310 | ||
311 | #if !defined(__MACTYPES__) | |
4a5b6a35 | 312 | typedef unsigned char Byte; /* 8 bits */ |
dce3d797 | 313 | #endif |
4a5b6a35 WD |
314 | typedef unsigned int uInt; /* 16 bits or more */ |
315 | typedef unsigned long uLong; /* 32 bits or more */ | |
316 | ||
dce3d797 GC |
317 | #ifdef SMALL_MEDIUM |
318 | /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ | |
319 | # define Bytef Byte FAR | |
320 | #else | |
321 | typedef Byte FAR Bytef; | |
322 | #endif | |
323 | typedef char FAR charf; | |
324 | typedef int FAR intf; | |
325 | typedef uInt FAR uIntf; | |
4a5b6a35 WD |
326 | typedef uLong FAR uLongf; |
327 | ||
328 | #ifdef STDC | |
dce3d797 GC |
329 | typedef void const *voidpc; |
330 | typedef void FAR *voidpf; | |
331 | typedef void *voidp; | |
4a5b6a35 | 332 | #else |
dce3d797 GC |
333 | typedef Byte const *voidpc; |
334 | typedef Byte FAR *voidpf; | |
335 | typedef Byte *voidp; | |
b201171f | 336 | #endif |
4a5b6a35 | 337 | |
dce3d797 GC |
338 | # ifdef VMS |
339 | # include <unixio.h> /* for off_t */ | |
340 | # endif | |
341 | # define z_off_t off_t | |
342 | #ifndef SEEK_SET | |
343 | # define SEEK_SET 0 /* Seek from beginning of file. */ | |
344 | # define SEEK_CUR 1 /* Seek from current position. */ | |
345 | # define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ | |
346 | #endif | |
347 | #ifndef z_off_t | |
348 | # define z_off_t long | |
349 | #endif | |
350 | ||
351 | #if defined(__OS400__) | |
352 | # define NO_vsnprintf | |
353 | #endif | |
b201171f | 354 | |
dce3d797 GC |
355 | #if defined(__MVS__) |
356 | # define NO_vsnprintf | |
357 | # ifdef FAR | |
358 | # undef FAR | |
359 | # endif | |
360 | #endif | |
361 | ||
362 | /* MVS linker does not support external names larger than 8 bytes */ | |
363 | #if defined(__MVS__) | |
364 | # pragma map(deflateInit_,"DEIN") | |
365 | # pragma map(deflateInit2_,"DEIN2") | |
366 | # pragma map(deflateEnd,"DEEND") | |
367 | # pragma map(deflateBound,"DEBND") | |
368 | # pragma map(inflateInit_,"ININ") | |
369 | # pragma map(inflateInit2_,"ININ2") | |
370 | # pragma map(inflateEnd,"INEND") | |
371 | # pragma map(inflateSync,"INSY") | |
372 | # pragma map(inflateSetDictionary,"INSEDI") | |
373 | # pragma map(compressBound,"CMBND") | |
374 | # pragma map(inflate_table,"INTABL") | |
375 | # pragma map(inflate_fast,"INFA") | |
376 | # pragma map(inflate_copyright,"INCOPY") | |
377 | #endif | |
378 | /* End of new zconf.h */ | |
4a5b6a35 WD |
379 | |
380 | /* | |
381 | The 'zlib' compression library provides in-memory compression and | |
382 | decompression functions, including integrity checks of the uncompressed | |
383 | data. This version of the library supports only one compression method | |
dce3d797 | 384 | (deflation) but other algorithms will be added later and will have the same |
4a5b6a35 WD |
385 | stream interface. |
386 | ||
4a5b6a35 WD |
387 | Compression can be done in a single step if the buffers are large |
388 | enough (for example if an input file is mmap'ed), or can be done by | |
389 | repeated calls of the compression function. In the latter case, the | |
390 | application must provide more input and/or consume the output | |
391 | (providing more output space) before each call. | |
f33b325a | 392 | |
dce3d797 GC |
393 | The compressed data format used by default by the in-memory functions is |
394 | the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped | |
395 | around a deflate stream, which is itself documented in RFC 1951. | |
4a5b6a35 | 396 | |
dce3d797 GC |
397 | The library also supports reading and writing files in gzip (.gz) format |
398 | with an interface similar to that of stdio using the functions that start | |
399 | with "gz". The gzip format is different from the zlib format. gzip is a | |
400 | gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. | |
f33b325a | 401 | |
dce3d797 | 402 | This library can optionally read and write gzip streams in memory as well. |
f33b325a | 403 | |
dce3d797 GC |
404 | The zlib format was designed to be compact and fast for use in memory |
405 | and on communications channels. The gzip format was designed for single- | |
406 | file compression on file systems, has a larger header than zlib to maintain | |
407 | directory information, and uses a different, slower check method than zlib. | |
f33b325a | 408 | |
dce3d797 GC |
409 | The library does not install any signal handler. The decoder checks |
410 | the consistency of the compressed data, so the library should never | |
411 | crash even in case of corrupted input. | |
412 | */ | |
4a5b6a35 | 413 | |
dce3d797 GC |
414 | typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); |
415 | typedef void (*free_func) OF((voidpf opaque, voidpf address, uInt size)); | |
416 | typedef void (*cb_func) OF((Bytef *buf, uInt len)); | |
f33b325a | 417 | |
dce3d797 | 418 | struct internal_state; |
f33b325a | 419 | |
dce3d797 GC |
420 | typedef struct z_stream_s { |
421 | Bytef *next_in; /* next input byte */ | |
422 | uInt avail_in; /* number of bytes available at next_in */ | |
423 | uLong total_in; /* total nb of input bytes read so far */ | |
424 | Bytef *next_out; /* next output byte should be put there */ | |
425 | uInt avail_out; /* remaining free space at next_out */ | |
426 | uLong total_out; /* total nb of bytes output so far */ | |
427 | char *msg; /* last error message, NULL if no error */ | |
428 | struct internal_state FAR *state; /* not visible by applications */ | |
429 | alloc_func zalloc; /* used to allocate the internal state */ | |
430 | free_func zfree; /* used to free the internal state */ | |
431 | voidpf opaque; /* private data object passed to zalloc and zfree */ | |
432 | int data_type; /* best guess about the data type: | |
433 | binary or text */ | |
434 | cb_func outcb; /* called regularly just before blocks of output */ | |
435 | uLong adler; /* adler32 value of the uncompressed data */ | |
436 | uLong reserved; /* reserved for future use */ | |
f33b325a | 437 | } z_stream; |
b201171f | 438 | |
dce3d797 GC |
439 | typedef z_stream FAR *z_streamp; |
440 | ||
4a5b6a35 | 441 | /* |
dce3d797 GC |
442 | gzip header information passed to and from zlib routines. See RFC 1952 |
443 | for more details on the meanings of these fields. | |
4a5b6a35 | 444 | */ |
dce3d797 GC |
445 | typedef struct gz_header_s { |
446 | int text; /* true if compressed data believed to be text */ | |
447 | uLong time; /* modification time */ | |
448 | int xflags; /* extra flags (not used when writing a gzip file) */ | |
449 | int os; /* operating system */ | |
450 | Bytef *extra; /* pointer to extra field or Z_NULL if none */ | |
451 | uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ | |
452 | uInt extra_max; /* space at extra (only when reading header) */ | |
453 | Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ | |
454 | uInt name_max; /* space at name (only when reading header) */ | |
455 | Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ | |
456 | uInt comm_max; /* space at comment (only when reading header) */ | |
457 | int hcrc; /* true if there was or will be a header crc */ | |
458 | int done; /* true when done reading gzip header (not used | |
459 | when writing a gzip file) */ | |
460 | } gz_header; | |
461 | ||
462 | typedef gz_header FAR *gz_headerp; | |
463 | ||
464 | /* constants */ | |
4a5b6a35 | 465 | #define Z_NO_FLUSH 0 |
dce3d797 GC |
466 | #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ |
467 | #define Z_SYNC_FLUSH 2 | |
468 | #define Z_FULL_FLUSH 3 | |
4a5b6a35 | 469 | #define Z_FINISH 4 |
dce3d797 GC |
470 | #define Z_BLOCK 5 |
471 | /* Allowed flush values; see deflate() and inflate() below for details */ | |
4a5b6a35 WD |
472 | |
473 | #define Z_OK 0 | |
474 | #define Z_STREAM_END 1 | |
dce3d797 | 475 | #define Z_NEED_DICT 2 |
4a5b6a35 WD |
476 | #define Z_ERRNO (-1) |
477 | #define Z_STREAM_ERROR (-2) | |
478 | #define Z_DATA_ERROR (-3) | |
479 | #define Z_MEM_ERROR (-4) | |
480 | #define Z_BUF_ERROR (-5) | |
dce3d797 GC |
481 | #define Z_VERSION_ERROR (-6) |
482 | /* Return codes for the compression/decompression functions. Negative | |
483 | * values are errors, positive values are used for special but normal events. | |
484 | */ | |
4a5b6a35 | 485 | |
dce3d797 | 486 | #define Z_NO_COMPRESSION 0 |
4a5b6a35 WD |
487 | #define Z_BEST_SPEED 1 |
488 | #define Z_BEST_COMPRESSION 9 | |
489 | #define Z_DEFAULT_COMPRESSION (-1) | |
490 | /* compression levels */ | |
491 | ||
492 | #define Z_FILTERED 1 | |
493 | #define Z_HUFFMAN_ONLY 2 | |
dce3d797 GC |
494 | #define Z_RLE 3 |
495 | #define Z_FIXED 4 | |
4a5b6a35 | 496 | #define Z_DEFAULT_STRATEGY 0 |
dce3d797 | 497 | /* compression strategy; see deflateInit2() below for details */ |
4a5b6a35 WD |
498 | |
499 | #define Z_BINARY 0 | |
dce3d797 GC |
500 | #define Z_TEXT 1 |
501 | #define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ | |
4a5b6a35 | 502 | #define Z_UNKNOWN 2 |
dce3d797 GC |
503 | /* Possible values of the data_type field (though see inflate()) */ |
504 | ||
505 | #define Z_DEFLATED 8 | |
506 | /* The deflate compression method (the only one supported in this version) */ | |
4a5b6a35 | 507 | |
ee820b5e | 508 | #define Z_NULL (void *)0 /* for initializing zalloc, zfree, opaque */ |
4a5b6a35 | 509 | |
dce3d797 GC |
510 | /* basic functions */ |
511 | ||
512 | /* The application can compare zlibVersion and ZLIB_VERSION for consistency. | |
4a5b6a35 WD |
513 | If the first character differs, the library code actually used is |
514 | not compatible with the zlib.h header file used by the application. | |
dce3d797 | 515 | This check is automatically made by deflateInit and inflateInit. |
7a32b98d LW |
516 | */ |
517 | ||
518 | ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); | |
519 | ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, | |
520 | const char *version, int stream_size)); | |
521 | ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); | |
522 | ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, | |
523 | int windowBits, int memLevel, | |
524 | int strategy, const char *version, | |
525 | int stream_size)); | |
526 | ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); | |
527 | ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, | |
528 | const Bytef *dictionary, | |
529 | uInt dictLength)); | |
530 | ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, | |
531 | gz_headerp head)); | |
532 | ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, | |
533 | int bits, | |
534 | int value)); | |
535 | ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, | |
536 | int level, | |
537 | int strategy)); | |
538 | ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, | |
539 | int good_length, | |
540 | int max_lazy, | |
541 | int nice_length, | |
542 | int max_chain)); | |
543 | ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, | |
544 | uLong sourceLen)); | |
545 | ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, | |
546 | z_streamp source)); | |
547 | ||
548 | ||
549 | ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, | |
550 | const char *version, int stream_size)); | |
dce3d797 | 551 | ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); |
4a5b6a35 | 552 | /* |
dce3d797 GC |
553 | inflate decompresses as much data as possible, and stops when the input |
554 | buffer becomes empty or the output buffer becomes full. It may introduce | |
555 | some output latency (reading input without producing any output) except when | |
556 | forced to flush. | |
4a5b6a35 | 557 | |
dce3d797 GC |
558 | The detailed semantics are as follows. inflate performs one or both of the |
559 | following actions: | |
4a5b6a35 WD |
560 | |
561 | - Decompress more input starting at next_in and update next_in and avail_in | |
562 | accordingly. If not all input can be processed (because there is not | |
563 | enough room in the output buffer), next_in is updated and processing | |
564 | will resume at this point for the next call of inflate(). | |
565 | ||
566 | - Provide more output starting at next_out and update next_out and avail_out | |
dce3d797 GC |
567 | accordingly. inflate() provides as much output as possible, until there |
568 | is no more input data or no more space in the output buffer (see below | |
569 | about the flush parameter). | |
4a5b6a35 WD |
570 | |
571 | Before the call of inflate(), the application should ensure that at least | |
572 | one of the actions is possible, by providing more input and/or consuming | |
573 | more output, and updating the next_* and avail_* values accordingly. | |
574 | The application can consume the uncompressed output when it wants, for | |
575 | example when the output buffer is full (avail_out == 0), or after each | |
dce3d797 GC |
576 | call of inflate(). If inflate returns Z_OK and with zero avail_out, it |
577 | must be called again after making room in the output buffer because there | |
578 | might be more output pending. | |
579 | ||
580 | The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, | |
581 | Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much | |
582 | output as possible to the output buffer. Z_BLOCK requests that inflate() stop | |
583 | if and when it gets to the next deflate block boundary. When decoding the | |
584 | zlib or gzip format, this will cause inflate() to return immediately after | |
585 | the header and before the first block. When doing a raw inflate, inflate() | |
586 | will go ahead and process the first block, and will return when it gets to | |
587 | the end of that block, or when it runs out of data. | |
588 | ||
589 | The Z_BLOCK option assists in appending to or combining deflate streams. | |
590 | Also to assist in this, on return inflate() will set strm->data_type to the | |
591 | number of unused bits in the last byte taken from strm->next_in, plus 64 | |
592 | if inflate() is currently decoding the last block in the deflate stream, | |
593 | plus 128 if inflate() returned immediately after decoding an end-of-block | |
594 | code or decoding the complete header up to just before the first byte of the | |
595 | deflate stream. The end-of-block will not be indicated until all of the | |
596 | uncompressed data from that block has been written to strm->next_out. The | |
597 | number of unused bits may in general be greater than seven, except when | |
598 | bit 7 of data_type is set, in which case the number of unused bits will be | |
599 | less than eight. | |
4a5b6a35 WD |
600 | |
601 | inflate() should normally be called until it returns Z_STREAM_END or an | |
602 | error. However if all decompression is to be performed in a single step | |
603 | (a single call of inflate), the parameter flush should be set to | |
604 | Z_FINISH. In this case all pending input is processed and all pending | |
605 | output is flushed; avail_out must be large enough to hold all the | |
606 | uncompressed data. (The size of the uncompressed data may have been saved | |
607 | by the compressor for this purpose.) The next operation on this stream must | |
608 | be inflateEnd to deallocate the decompression state. The use of Z_FINISH | |
dce3d797 | 609 | is never required, but can be used to inform inflate that a faster approach |
4a5b6a35 WD |
610 | may be used for the single inflate() call. |
611 | ||
dce3d797 GC |
612 | In this implementation, inflate() always flushes as much output as |
613 | possible to the output buffer, and always uses the faster approach on the | |
614 | first call. So the only effect of the flush parameter in this implementation | |
615 | is on the return value of inflate(), as noted below, or when it returns early | |
616 | because Z_BLOCK is used. | |
617 | ||
618 | If a preset dictionary is needed after this call (see inflateSetDictionary | |
619 | below), inflate sets strm->adler to the adler32 checksum of the dictionary | |
620 | chosen by the compressor and returns Z_NEED_DICT; otherwise it sets | |
621 | strm->adler to the adler32 checksum of all output produced so far (that is, | |
622 | total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described | |
623 | below. At the end of the stream, inflate() checks that its computed adler32 | |
624 | checksum is equal to that saved by the compressor and returns Z_STREAM_END | |
625 | only if the checksum is correct. | |
626 | ||
627 | inflate() will decompress and check either zlib-wrapped or gzip-wrapped | |
628 | deflate data. The header type is detected automatically. Any information | |
629 | contained in the gzip header is not retained, so applications that need that | |
630 | information should instead use raw inflate, see inflateInit2() below, or | |
631 | inflateBack() and perform their own processing of the gzip header and | |
632 | trailer. | |
633 | ||
634 | inflate() returns Z_OK if some progress has been made (more input processed | |
635 | or more output produced), Z_STREAM_END if the end of the compressed data has | |
636 | been reached and all uncompressed output has been produced, Z_NEED_DICT if a | |
637 | preset dictionary is needed at this point, Z_DATA_ERROR if the input data was | |
638 | corrupted (input stream not conforming to the zlib format or incorrect check | |
639 | value), Z_STREAM_ERROR if the stream structure was inconsistent (for example | |
640 | if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, | |
641 | Z_BUF_ERROR if no progress is possible or if there was not enough room in the | |
642 | output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and | |
643 | inflate() can be called again with more input and more output space to | |
644 | continue decompressing. If Z_DATA_ERROR is returned, the application may then | |
645 | call inflateSync() to look for a good compression block if a partial recovery | |
646 | of the data is desired. | |
647 | */ | |
4a5b6a35 | 648 | |
dce3d797 | 649 | ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); |
4a5b6a35 WD |
650 | /* |
651 | All dynamically allocated data structures for this stream are freed. | |
652 | This function discards any unprocessed input and does not flush any | |
653 | pending output. | |
654 | ||
655 | inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state | |
656 | was inconsistent. In the error case, msg may be set but then points to a | |
657 | static string (which must not be deallocated). | |
658 | */ | |
659 | ||
dce3d797 | 660 | /* Advanced functions */ |
4a5b6a35 | 661 | |
dce3d797 | 662 | ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); |
f33b325a | 663 | |
dce3d797 | 664 | /* utility functions */ |
f33b325a | 665 | |
f33b325a | 666 | /* |
dce3d797 GC |
667 | The following utility functions are implemented on top of the |
668 | basic stream-oriented functions. To simplify the interface, some | |
669 | default options are assumed (compression level and memory usage, | |
670 | standard memory allocation functions). The source code of these | |
671 | utility functions can easily be modified if you need special options. | |
f33b325a WD |
672 | */ |
673 | ||
dce3d797 | 674 | ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); |
4a5b6a35 WD |
675 | /* |
676 | Update a running Adler-32 checksum with the bytes buf[0..len-1] and | |
677 | return the updated checksum. If buf is NULL, this function returns | |
678 | the required initial value for the checksum. | |
679 | An Adler-32 checksum is almost as reliable as a CRC32 but can be computed | |
680 | much faster. Usage example: | |
681 | ||
682 | uLong adler = adler32(0L, Z_NULL, 0); | |
683 | ||
684 | while (read_buffer(buffer, length) != EOF) { | |
685 | adler = adler32(adler, buffer, length); | |
686 | } | |
687 | if (adler != original_adler) error(); | |
688 | */ | |
689 | ||
dce3d797 GC |
690 | /* |
691 | Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 | |
692 | and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for | |
693 | each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of | |
694 | seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. | |
695 | */ | |
696 | ||
697 | ZEXTERN uInt ZEXPORT crc32 OF((uInt crc, const Bytef *buf, uInt len)); | |
698 | /* | |
699 | Update a running CRC-32 with the bytes buf[0..len-1] and return the | |
700 | updated CRC-32. If buf is NULL, this function returns the required initial | |
701 | value for the for the crc. Pre- and post-conditioning (one's complement) is | |
702 | performed within this function so it shouldn't be done by the application. | |
703 | Usage example: | |
704 | ||
705 | uLong crc = crc32(0L, Z_NULL, 0); | |
706 | ||
707 | while (read_buffer(buffer, length) != EOF) { | |
708 | crc = crc32(crc, buffer, length); | |
709 | } | |
710 | if (crc != original_crc) error(); | |
711 | */ | |
712 | ||
713 | ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, | |
714 | const char *version, int stream_size)); | |
715 | #define inflateInit(strm) \ | |
716 | inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) | |
717 | #define inflateInit2(strm, windowBits) \ | |
718 | inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) | |
719 | ||
720 | #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) | |
721 | struct internal_state {int dummy;}; /* hack for buggy compilers */ | |
722 | #endif | |
723 | ||
e3ed0575 MF |
724 | extern void *gzalloc(void *, unsigned, unsigned); |
725 | extern void gzfree(void *, void *, unsigned); | |
726 | ||
dce3d797 GC |
727 | #ifdef __cplusplus |
728 | } | |
4a5b6a35 WD |
729 | #endif |
730 | ||
dce3d797 | 731 | #endif /* ZLIB_H */ |