1 /* zlib.h -- interface of the 'zlib' general purpose compression library 2 version 1.2.13, October 13th, 2022 3 4 Copyright (C) 1995-2022 Jean-loup Gailly and Mark Adler 5 6 This software is provided 'as-is', without any express or implied 7 warranty. In no event will the authors be held liable for any damages 8 arising from the use of this software. 9 10 Permission is granted to anyone to use this software for any purpose, 11 including commercial applications, and to alter it and redistribute it 12 freely, subject to the following restrictions: 13 14 1. The origin of this software must not be misrepresented; you must not 15 claim that you wrote the original software. If you use this software 16 in a product, an acknowledgment in the product documentation would be 17 appreciated but is not required. 18 2. Altered source versions must be plainly marked as such, and must not be 19 misrepresented as being the original software. 20 3. This notice may not be removed or altered from any source distribution. 21 22 Jean-loup Gailly Mark Adler 23 [email protected] [email protected] 24 25 26 The data format used by the zlib library is described by RFCs (Request for 27 Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 28 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). 29 */ 30 31 #ifndef ZLIB_H 32 #define ZLIB_H 33 34 #include "zconf.h" 35 36 #ifdef __cplusplus 37 extern "C" { 38 #endif 39 40 #define ZLIB_VERSION "1.2.13" 41 #define ZLIB_VERNUM 0x12d0 42 #define ZLIB_VER_MAJOR 1 43 #define ZLIB_VER_MINOR 2 44 #define ZLIB_VER_REVISION 13 45 #define ZLIB_VER_SUBREVISION 0 46 47 /* 48 * In Android's NDK we have one zlib.h for all the versions. 49 * zlib users tend to use ZLIB_VERNUM to check API availability, 50 * so we need to translate __ANDROID_API__ appropriately. 51 * 52 * ZLIB_1.2.7.1 and ZLIB_1.2.9 are the only API changes in the NDK's 53 * supported range of API levels. 54 * 55 * jb-mr2-dev (18): 1.2.7 (but not 1.2.7.1, where the APIs were added!) 56 * https://android.googlesource.com/platform/external/zlib/+/refs/heads/jb-mr2-dev/src/zlib.h 57 * kitkat-dev (19): 1.2.8 58 * https://android.googlesource.com/platform/external/zlib/+/refs/heads/kitkat-dev/src/zlib.h 59 * 60 * oreo-mr1-dev (27): 1.2.8 61 * https://android.googlesource.com/platform/external/zlib/+/refs/heads/oreo-mr1-dev/src/zlib.h 62 * pie-dev (28): 1.2.11 63 * https://android.googlesource.com/platform/external/zlib/+/refs/heads/pie-dev/src/zlib.h 64 * 65 * So: 66 * >= 28 --> 1.2.11 67 * >= 19 --> 1.2.8 68 * < 19 --> 1.2.7 69 */ 70 #if defined(__ANDROID__) 71 # if __ANDROID_API__ >= 28 72 /* Already okay. */ 73 # elif __ANDROID_API__ >= 19 74 # undef ZLIB_VERSION 75 # define ZLIB_VERSION "1.2.8" 76 # undef ZLIB_VERNUM 77 # define ZLIB_VERNUM 0x1280 78 # undef ZLIB_VER_REVISION 79 # define ZLIB_VER_REVISION 8 80 # else 81 # undef ZLIB_VERSION 82 # define ZLIB_VERSION "1.2.6" 83 # undef ZLIB_VERNUM 84 # define ZLIB_VERNUM 0x1260 85 # undef ZLIB_VER_REVISION 86 # define ZLIB_VER_REVISION 6 87 # endif 88 #endif 89 90 /* 91 The 'zlib' compression library provides in-memory compression and 92 decompression functions, including integrity checks of the uncompressed data. 93 This version of the library supports only one compression method (deflation) 94 but other algorithms will be added later and will have the same stream 95 interface. 96 97 Compression can be done in a single step if the buffers are large enough, 98 or can be done by repeated calls of the compression function. In the latter 99 case, the application must provide more input and/or consume the output 100 (providing more output space) before each call. 101 102 The compressed data format used by default by the in-memory functions is 103 the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped 104 around a deflate stream, which is itself documented in RFC 1951. 105 106 The library also supports reading and writing files in gzip (.gz) format 107 with an interface similar to that of stdio using the functions that start 108 with "gz". The gzip format is different from the zlib format. gzip is a 109 gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. 110 111 This library can optionally read and write gzip and raw deflate streams in 112 memory as well. 113 114 The zlib format was designed to be compact and fast for use in memory 115 and on communications channels. The gzip format was designed for single- 116 file compression on file systems, has a larger header than zlib to maintain 117 directory information, and uses a different, slower check method than zlib. 118 119 The library does not install any signal handler. The decoder checks 120 the consistency of the compressed data, so the library should never crash 121 even in the case of corrupted input. 122 */ 123 124 typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); 125 typedef void (*free_func) OF((voidpf opaque, voidpf address)); 126 127 struct internal_state; 128 129 typedef struct z_stream_s { 130 z_const Bytef *next_in; /* next input byte */ 131 uInt avail_in; /* number of bytes available at next_in */ 132 uLong total_in; /* total number of input bytes read so far */ 133 134 Bytef *next_out; /* next output byte will go here */ 135 uInt avail_out; /* remaining free space at next_out */ 136 uLong total_out; /* total number of bytes output so far */ 137 138 z_const char *msg; /* last error message, NULL if no error */ 139 struct internal_state FAR *state; /* not visible by applications */ 140 141 alloc_func zalloc; /* used to allocate the internal state */ 142 free_func zfree; /* used to free the internal state */ 143 voidpf opaque; /* private data object passed to zalloc and zfree */ 144 145 int data_type; /* best guess about the data type: binary or text 146 for deflate, or the decoding state for inflate */ 147 uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */ 148 uLong reserved; /* reserved for future use */ 149 } z_stream; 150 151 typedef z_stream FAR *z_streamp; 152 153 /* 154 gzip header information passed to and from zlib routines. See RFC 1952 155 for more details on the meanings of these fields. 156 */ 157 typedef struct gz_header_s { 158 int text; /* true if compressed data believed to be text */ 159 uLong time; /* modification time */ 160 int xflags; /* extra flags (not used when writing a gzip file) */ 161 int os; /* operating system */ 162 Bytef *extra; /* pointer to extra field or Z_NULL if none */ 163 uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ 164 uInt extra_max; /* space at extra (only when reading header) */ 165 Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ 166 uInt name_max; /* space at name (only when reading header) */ 167 Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ 168 uInt comm_max; /* space at comment (only when reading header) */ 169 int hcrc; /* true if there was or will be a header crc */ 170 int done; /* true when done reading gzip header (not used 171 when writing a gzip file) */ 172 } gz_header; 173 174 typedef gz_header FAR *gz_headerp; 175 176 /* 177 The application must update next_in and avail_in when avail_in has dropped 178 to zero. It must update next_out and avail_out when avail_out has dropped 179 to zero. The application must initialize zalloc, zfree and opaque before 180 calling the init function. All other fields are set by the compression 181 library and must not be updated by the application. 182 183 The opaque value provided by the application will be passed as the first 184 parameter for calls of zalloc and zfree. This can be useful for custom 185 memory management. The compression library attaches no meaning to the 186 opaque value. 187 188 zalloc must return Z_NULL if there is not enough memory for the object. 189 If zlib is used in a multi-threaded application, zalloc and zfree must be 190 thread safe. In that case, zlib is thread-safe. When zalloc and zfree are 191 Z_NULL on entry to the initialization function, they are set to internal 192 routines that use the standard library functions malloc() and free(). 193 194 On 16-bit systems, the functions zalloc and zfree must be able to allocate 195 exactly 65536 bytes, but will not be required to allocate more than this if 196 the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers 197 returned by zalloc for objects of exactly 65536 bytes *must* have their 198 offset normalized to zero. The default allocation function provided by this 199 library ensures this (see zutil.c). To reduce memory requirements and avoid 200 any allocation of 64K objects, at the expense of compression ratio, compile 201 the library with -DMAX_WBITS=14 (see zconf.h). 202 203 The fields total_in and total_out can be used for statistics or progress 204 reports. After compression, total_in holds the total size of the 205 uncompressed data and may be saved for use by the decompressor (particularly 206 if the decompressor wants to decompress everything in a single step). 207 */ 208 209 /* constants */ 210 211 #define Z_NO_FLUSH 0 212 #define Z_PARTIAL_FLUSH 1 213 #define Z_SYNC_FLUSH 2 214 #define Z_FULL_FLUSH 3 215 #define Z_FINISH 4 216 #define Z_BLOCK 5 217 #define Z_TREES 6 218 /* Allowed flush values; see deflate() and inflate() below for details */ 219 220 #define Z_OK 0 221 #define Z_STREAM_END 1 222 #define Z_NEED_DICT 2 223 #define Z_ERRNO (-1) 224 #define Z_STREAM_ERROR (-2) 225 #define Z_DATA_ERROR (-3) 226 #define Z_MEM_ERROR (-4) 227 #define Z_BUF_ERROR (-5) 228 #define Z_VERSION_ERROR (-6) 229 /* Return codes for the compression/decompression functions. Negative values 230 * are errors, positive values are used for special but normal events. 231 */ 232 233 #define Z_NO_COMPRESSION 0 234 #define Z_BEST_SPEED 1 235 #define Z_BEST_COMPRESSION 9 236 #define Z_DEFAULT_COMPRESSION (-1) 237 /* compression levels */ 238 239 #define Z_FILTERED 1 240 #define Z_HUFFMAN_ONLY 2 241 #define Z_RLE 3 242 #define Z_FIXED 4 243 #define Z_DEFAULT_STRATEGY 0 244 /* compression strategy; see deflateInit2() below for details */ 245 246 #define Z_BINARY 0 247 #define Z_TEXT 1 248 #define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ 249 #define Z_UNKNOWN 2 250 /* Possible values of the data_type field for deflate() */ 251 252 #define Z_DEFLATED 8 253 /* The deflate compression method (the only one supported in this version) */ 254 255 #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ 256 257 #define zlib_version zlibVersion() 258 /* for compatibility with versions < 1.0.2 */ 259 260 261 /* basic functions */ 262 263 ZEXTERN const char * ZEXPORT zlibVersion OF((void)); 264 /* The application can compare zlibVersion and ZLIB_VERSION for consistency. 265 If the first character differs, the library code actually used is not 266 compatible with the zlib.h header file used by the application. This check 267 is automatically made by deflateInit and inflateInit. 268 */ 269 270 /* 271 ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); 272 273 Initializes the internal stream state for compression. The fields 274 zalloc, zfree and opaque must be initialized before by the caller. If 275 zalloc and zfree are set to Z_NULL, deflateInit updates them to use default 276 allocation functions. 277 278 The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: 279 1 gives best speed, 9 gives best compression, 0 gives no compression at all 280 (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION 281 requests a default compromise between speed and compression (currently 282 equivalent to level 6). 283 284 deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough 285 memory, Z_STREAM_ERROR if level is not a valid compression level, or 286 Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible 287 with the version assumed by the caller (ZLIB_VERSION). msg is set to null 288 if there is no error message. deflateInit does not perform any compression: 289 this will be done by deflate(). 290 */ 291 292 293 ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); 294 /* 295 deflate compresses as much data as possible, and stops when the input 296 buffer becomes empty or the output buffer becomes full. It may introduce 297 some output latency (reading input without producing any output) except when 298 forced to flush. 299 300 The detailed semantics are as follows. deflate performs one or both of the 301 following actions: 302 303 - Compress more input starting at next_in and update next_in and avail_in 304 accordingly. If not all input can be processed (because there is not 305 enough room in the output buffer), next_in and avail_in are updated and 306 processing will resume at this point for the next call of deflate(). 307 308 - Generate more output starting at next_out and update next_out and avail_out 309 accordingly. This action is forced if the parameter flush is non zero. 310 Forcing flush frequently degrades the compression ratio, so this parameter 311 should be set only when necessary. Some output may be provided even if 312 flush is zero. 313 314 Before the call of deflate(), the application should ensure that at least 315 one of the actions is possible, by providing more input and/or consuming more 316 output, and updating avail_in or avail_out accordingly; avail_out should 317 never be zero before the call. The application can consume the compressed 318 output when it wants, for example when the output buffer is full (avail_out 319 == 0), or after each call of deflate(). If deflate returns Z_OK and with 320 zero avail_out, it must be called again after making room in the output 321 buffer because there might be more output pending. See deflatePending(), 322 which can be used if desired to determine whether or not there is more output 323 in that case. 324 325 Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to 326 decide how much data to accumulate before producing output, in order to 327 maximize compression. 328 329 If the parameter flush is set to Z_SYNC_FLUSH, all pending output is 330 flushed to the output buffer and the output is aligned on a byte boundary, so 331 that the decompressor can get all input data available so far. (In 332 particular avail_in is zero after the call if enough output space has been 333 provided before the call.) Flushing may degrade compression for some 334 compression algorithms and so it should be used only when necessary. This 335 completes the current deflate block and follows it with an empty stored block 336 that is three bits plus filler bits to the next byte, followed by four bytes 337 (00 00 ff ff). 338 339 If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the 340 output buffer, but the output is not aligned to a byte boundary. All of the 341 input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. 342 This completes the current deflate block and follows it with an empty fixed 343 codes block that is 10 bits long. This assures that enough bytes are output 344 in order for the decompressor to finish the block before the empty fixed 345 codes block. 346 347 If flush is set to Z_BLOCK, a deflate block is completed and emitted, as 348 for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to 349 seven bits of the current block are held to be written as the next byte after 350 the next deflate block is completed. In this case, the decompressor may not 351 be provided enough bits at this point in order to complete decompression of 352 the data provided so far to the compressor. It may need to wait for the next 353 block to be emitted. This is for advanced applications that need to control 354 the emission of deflate blocks. 355 356 If flush is set to Z_FULL_FLUSH, all output is flushed as with 357 Z_SYNC_FLUSH, and the compression state is reset so that decompression can 358 restart from this point if previous compressed data has been damaged or if 359 random access is desired. Using Z_FULL_FLUSH too often can seriously degrade 360 compression. 361 362 If deflate returns with avail_out == 0, this function must be called again 363 with the same value of the flush parameter and more output space (updated 364 avail_out), until the flush is complete (deflate returns with non-zero 365 avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that 366 avail_out is greater than six to avoid repeated flush markers due to 367 avail_out == 0 on return. 368 369 If the parameter flush is set to Z_FINISH, pending input is processed, 370 pending output is flushed and deflate returns with Z_STREAM_END if there was 371 enough output space. If deflate returns with Z_OK or Z_BUF_ERROR, this 372 function must be called again with Z_FINISH and more output space (updated 373 avail_out) but no more input data, until it returns with Z_STREAM_END or an 374 error. After deflate has returned Z_STREAM_END, the only possible operations 375 on the stream are deflateReset or deflateEnd. 376 377 Z_FINISH can be used in the first deflate call after deflateInit if all the 378 compression is to be done in a single step. In order to complete in one 379 call, avail_out must be at least the value returned by deflateBound (see 380 below). Then deflate is guaranteed to return Z_STREAM_END. If not enough 381 output space is provided, deflate will not return Z_STREAM_END, and it must 382 be called again as described above. 383 384 deflate() sets strm->adler to the Adler-32 checksum of all input read 385 so far (that is, total_in bytes). If a gzip stream is being generated, then 386 strm->adler will be the CRC-32 checksum of the input read so far. (See 387 deflateInit2 below.) 388 389 deflate() may update strm->data_type if it can make a good guess about 390 the input data type (Z_BINARY or Z_TEXT). If in doubt, the data is 391 considered binary. This field is only for information purposes and does not 392 affect the compression algorithm in any manner. 393 394 deflate() returns Z_OK if some progress has been made (more input 395 processed or more output produced), Z_STREAM_END if all input has been 396 consumed and all output has been produced (only when flush is set to 397 Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example 398 if next_in or next_out was Z_NULL or the state was inadvertently written over 399 by the application), or Z_BUF_ERROR if no progress is possible (for example 400 avail_in or avail_out was zero). Note that Z_BUF_ERROR is not fatal, and 401 deflate() can be called again with more input and more output space to 402 continue compressing. 403 */ 404 405 ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); 406 /* 407 All dynamically allocated data structures for this stream are freed. 408 This function discards any unprocessed input and does not flush any pending 409 output. 410 411 deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the 412 stream state was inconsistent, Z_DATA_ERROR if the stream was freed 413 prematurely (some input or output was discarded). In the error case, msg 414 may be set but then points to a static string (which must not be 415 deallocated). 416 */ 417 418 419 /* 420 ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); 421 422 Initializes the internal stream state for decompression. The fields 423 next_in, avail_in, zalloc, zfree and opaque must be initialized before by 424 the caller. In the current version of inflate, the provided input is not 425 read or consumed. The allocation of a sliding window will be deferred to 426 the first call of inflate (if the decompression does not complete on the 427 first call). If zalloc and zfree are set to Z_NULL, inflateInit updates 428 them to use default allocation functions. 429 430 inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough 431 memory, Z_VERSION_ERROR if the zlib library version is incompatible with the 432 version assumed by the caller, or Z_STREAM_ERROR if the parameters are 433 invalid, such as a null pointer to the structure. msg is set to null if 434 there is no error message. inflateInit does not perform any decompression. 435 Actual decompression will be done by inflate(). So next_in, and avail_in, 436 next_out, and avail_out are unused and unchanged. The current 437 implementation of inflateInit() does not process any header information -- 438 that is deferred until inflate() is called. 439 */ 440 441 442 ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); 443 /* 444 inflate decompresses as much data as possible, and stops when the input 445 buffer becomes empty or the output buffer becomes full. It may introduce 446 some output latency (reading input without producing any output) except when 447 forced to flush. 448 449 The detailed semantics are as follows. inflate performs one or both of the 450 following actions: 451 452 - Decompress more input starting at next_in and update next_in and avail_in 453 accordingly. If not all input can be processed (because there is not 454 enough room in the output buffer), then next_in and avail_in are updated 455 accordingly, and processing will resume at this point for the next call of 456 inflate(). 457 458 - Generate more output starting at next_out and update next_out and avail_out 459 accordingly. inflate() provides as much output as possible, until there is 460 no more input data or no more space in the output buffer (see below about 461 the flush parameter). 462 463 Before the call of inflate(), the application should ensure that at least 464 one of the actions is possible, by providing more input and/or consuming more 465 output, and updating the next_* and avail_* values accordingly. If the 466 caller of inflate() does not provide both available input and available 467 output space, it is possible that there will be no progress made. The 468 application can consume the uncompressed output when it wants, for example 469 when the output buffer is full (avail_out == 0), or after each call of 470 inflate(). If inflate returns Z_OK and with zero avail_out, it must be 471 called again after making room in the output buffer because there might be 472 more output pending. 473 474 The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, 475 Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much 476 output as possible to the output buffer. Z_BLOCK requests that inflate() 477 stop if and when it gets to the next deflate block boundary. When decoding 478 the zlib or gzip format, this will cause inflate() to return immediately 479 after the header and before the first block. When doing a raw inflate, 480 inflate() will go ahead and process the first block, and will return when it 481 gets to the end of that block, or when it runs out of data. 482 483 The Z_BLOCK option assists in appending to or combining deflate streams. 484 To assist in this, on return inflate() always sets strm->data_type to the 485 number of unused bits in the last byte taken from strm->next_in, plus 64 if 486 inflate() is currently decoding the last block in the deflate stream, plus 487 128 if inflate() returned immediately after decoding an end-of-block code or 488 decoding the complete header up to just before the first byte of the deflate 489 stream. The end-of-block will not be indicated until all of the uncompressed 490 data from that block has been written to strm->next_out. The number of 491 unused bits may in general be greater than seven, except when bit 7 of 492 data_type is set, in which case the number of unused bits will be less than 493 eight. data_type is set as noted here every time inflate() returns for all 494 flush options, and so can be used to determine the amount of currently 495 consumed input in bits. 496 497 The Z_TREES option behaves as Z_BLOCK does, but it also returns when the 498 end of each deflate block header is reached, before any actual data in that 499 block is decoded. This allows the caller to determine the length of the 500 deflate block header for later use in random access within a deflate block. 501 256 is added to the value of strm->data_type when inflate() returns 502 immediately after reaching the end of the deflate block header. 503 504 inflate() should normally be called until it returns Z_STREAM_END or an 505 error. However if all decompression is to be performed in a single step (a 506 single call of inflate), the parameter flush should be set to Z_FINISH. In 507 this case all pending input is processed and all pending output is flushed; 508 avail_out must be large enough to hold all of the uncompressed data for the 509 operation to complete. (The size of the uncompressed data may have been 510 saved by the compressor for this purpose.) The use of Z_FINISH is not 511 required to perform an inflation in one step. However it may be used to 512 inform inflate that a faster approach can be used for the single inflate() 513 call. Z_FINISH also informs inflate to not maintain a sliding window if the 514 stream completes, which reduces inflate's memory footprint. If the stream 515 does not complete, either because not all of the stream is provided or not 516 enough output space is provided, then a sliding window will be allocated and 517 inflate() can be called again to continue the operation as if Z_NO_FLUSH had 518 been used. 519 520 In this implementation, inflate() always flushes as much output as 521 possible to the output buffer, and always uses the faster approach on the 522 first call. So the effects of the flush parameter in this implementation are 523 on the return value of inflate() as noted below, when inflate() returns early 524 when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of 525 memory for a sliding window when Z_FINISH is used. 526 527 If a preset dictionary is needed after this call (see inflateSetDictionary 528 below), inflate sets strm->adler to the Adler-32 checksum of the dictionary 529 chosen by the compressor and returns Z_NEED_DICT; otherwise it sets 530 strm->adler to the Adler-32 checksum of all output produced so far (that is, 531 total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described 532 below. At the end of the stream, inflate() checks that its computed Adler-32 533 checksum is equal to that saved by the compressor and returns Z_STREAM_END 534 only if the checksum is correct. 535 536 inflate() can decompress and check either zlib-wrapped or gzip-wrapped 537 deflate data. The header type is detected automatically, if requested when 538 initializing with inflateInit2(). Any information contained in the gzip 539 header is not retained unless inflateGetHeader() is used. When processing 540 gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output 541 produced so far. The CRC-32 is checked against the gzip trailer, as is the 542 uncompressed length, modulo 2^32. 543 544 inflate() returns Z_OK if some progress has been made (more input processed 545 or more output produced), Z_STREAM_END if the end of the compressed data has 546 been reached and all uncompressed output has been produced, Z_NEED_DICT if a 547 preset dictionary is needed at this point, Z_DATA_ERROR if the input data was 548 corrupted (input stream not conforming to the zlib format or incorrect check 549 value, in which case strm->msg points to a string with a more specific 550 error), Z_STREAM_ERROR if the stream structure was inconsistent (for example 551 next_in or next_out was Z_NULL, or the state was inadvertently written over 552 by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR 553 if no progress was possible or if there was not enough room in the output 554 buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and 555 inflate() can be called again with more input and more output space to 556 continue decompressing. If Z_DATA_ERROR is returned, the application may 557 then call inflateSync() to look for a good compression block if a partial 558 recovery of the data is to be attempted. 559 */ 560 561 562 ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); 563 /* 564 All dynamically allocated data structures for this stream are freed. 565 This function discards any unprocessed input and does not flush any pending 566 output. 567 568 inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state 569 was inconsistent. 570 */ 571 572 573 /* Advanced functions */ 574 575 /* 576 The following functions are needed only in some special applications. 577 */ 578 579 /* 580 ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, 581 int level, 582 int method, 583 int windowBits, 584 int memLevel, 585 int strategy)); 586 587 This is another version of deflateInit with more compression options. The 588 fields zalloc, zfree and opaque must be initialized before by the caller. 589 590 The method parameter is the compression method. It must be Z_DEFLATED in 591 this version of the library. 592 593 The windowBits parameter is the base two logarithm of the window size 594 (the size of the history buffer). It should be in the range 8..15 for this 595 version of the library. Larger values of this parameter result in better 596 compression at the expense of memory usage. The default value is 15 if 597 deflateInit is used instead. 598 599 For the current implementation of deflate(), a windowBits value of 8 (a 600 window size of 256 bytes) is not supported. As a result, a request for 8 601 will result in 9 (a 512-byte window). In that case, providing 8 to 602 inflateInit2() will result in an error when the zlib header with 9 is 603 checked against the initialization of inflate(). The remedy is to not use 8 604 with deflateInit2() with this initialization, or at least in that case use 9 605 with inflateInit2(). 606 607 windowBits can also be -8..-15 for raw deflate. In this case, -windowBits 608 determines the window size. deflate() will then generate raw deflate data 609 with no zlib header or trailer, and will not compute a check value. 610 611 windowBits can also be greater than 15 for optional gzip encoding. Add 612 16 to windowBits to write a simple gzip header and trailer around the 613 compressed data instead of a zlib wrapper. The gzip header will have no 614 file name, no extra data, no comment, no modification time (set to zero), no 615 header crc, and the operating system will be set to the appropriate value, 616 if the operating system was determined at compile time. If a gzip stream is 617 being written, strm->adler is a CRC-32 instead of an Adler-32. 618 619 For raw deflate or gzip encoding, a request for a 256-byte window is 620 rejected as invalid, since only the zlib header provides a means of 621 transmitting the window size to the decompressor. 622 623 The memLevel parameter specifies how much memory should be allocated 624 for the internal compression state. memLevel=1 uses minimum memory but is 625 slow and reduces compression ratio; memLevel=9 uses maximum memory for 626 optimal speed. The default value is 8. See zconf.h for total memory usage 627 as a function of windowBits and memLevel. 628 629 The strategy parameter is used to tune the compression algorithm. Use the 630 value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a 631 filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no 632 string match), or Z_RLE to limit match distances to one (run-length 633 encoding). Filtered data consists mostly of small values with a somewhat 634 random distribution. In this case, the compression algorithm is tuned to 635 compress them better. The effect of Z_FILTERED is to force more Huffman 636 coding and less string matching; it is somewhat intermediate between 637 Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as 638 fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The 639 strategy parameter only affects the compression ratio but not the 640 correctness of the compressed output even if it is not set appropriately. 641 Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler 642 decoder for special applications. 643 644 deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 645 memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid 646 method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is 647 incompatible with the version assumed by the caller (ZLIB_VERSION). msg is 648 set to null if there is no error message. deflateInit2 does not perform any 649 compression: this will be done by deflate(). 650 */ 651 652 ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, 653 const Bytef *dictionary, 654 uInt dictLength)); 655 /* 656 Initializes the compression dictionary from the given byte sequence 657 without producing any compressed output. When using the zlib format, this 658 function must be called immediately after deflateInit, deflateInit2 or 659 deflateReset, and before any call of deflate. When doing raw deflate, this 660 function must be called either before any call of deflate, or immediately 661 after the completion of a deflate block, i.e. after all input has been 662 consumed and all output has been delivered when using any of the flush 663 options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The 664 compressor and decompressor must use exactly the same dictionary (see 665 inflateSetDictionary). 666 667 The dictionary should consist of strings (byte sequences) that are likely 668 to be encountered later in the data to be compressed, with the most commonly 669 used strings preferably put towards the end of the dictionary. Using a 670 dictionary is most useful when the data to be compressed is short and can be 671 predicted with good accuracy; the data can then be compressed better than 672 with the default empty dictionary. 673 674 Depending on the size of the compression data structures selected by 675 deflateInit or deflateInit2, a part of the dictionary may in effect be 676 discarded, for example if the dictionary is larger than the window size 677 provided in deflateInit or deflateInit2. Thus the strings most likely to be 678 useful should be put at the end of the dictionary, not at the front. In 679 addition, the current implementation of deflate will use at most the window 680 size minus 262 bytes of the provided dictionary. 681 682 Upon return of this function, strm->adler is set to the Adler-32 value 683 of the dictionary; the decompressor may later use this value to determine 684 which dictionary has been used by the compressor. (The Adler-32 value 685 applies to the whole dictionary even if only a subset of the dictionary is 686 actually used by the compressor.) If a raw deflate was requested, then the 687 Adler-32 value is not computed and strm->adler is not set. 688 689 deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a 690 parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is 691 inconsistent (for example if deflate has already been called for this stream 692 or if not at a block boundary for raw deflate). deflateSetDictionary does 693 not perform any compression: this will be done by deflate(). 694 */ 695 696 #if !defined(__ANDROID__) || __ANDROID_API__ >= 28 697 ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm, 698 Bytef *dictionary, 699 uInt *dictLength)); 700 #endif 701 /* 702 Returns the sliding dictionary being maintained by deflate. dictLength is 703 set to the number of bytes in the dictionary, and that many bytes are copied 704 to dictionary. dictionary must have enough space, where 32768 bytes is 705 always enough. If deflateGetDictionary() is called with dictionary equal to 706 Z_NULL, then only the dictionary length is returned, and nothing is copied. 707 Similarly, if dictLength is Z_NULL, then it is not set. 708 709 deflateGetDictionary() may return a length less than the window size, even 710 when more than the window size in input has been provided. It may return up 711 to 258 bytes less in that case, due to how zlib's implementation of deflate 712 manages the sliding window and lookahead for matches, where matches can be 713 up to 258 bytes long. If the application needs the last window-size bytes of 714 input, then that would need to be saved by the application outside of zlib. 715 716 deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the 717 stream state is inconsistent. 718 */ 719 720 ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, 721 z_streamp source)); 722 /* 723 Sets the destination stream as a complete copy of the source stream. 724 725 This function can be useful when several compression strategies will be 726 tried, for example when there are several ways of pre-processing the input 727 data with a filter. The streams that will be discarded should then be freed 728 by calling deflateEnd. Note that deflateCopy duplicates the internal 729 compression state which can be quite large, so this strategy is slow and can 730 consume lots of memory. 731 732 deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not 733 enough memory, Z_STREAM_ERROR if the source stream state was inconsistent 734 (such as zalloc being Z_NULL). msg is left unchanged in both source and 735 destination. 736 */ 737 738 ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); 739 /* 740 This function is equivalent to deflateEnd followed by deflateInit, but 741 does not free and reallocate the internal compression state. The stream 742 will leave the compression level and any other attributes that may have been 743 set unchanged. 744 745 deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source 746 stream state was inconsistent (such as zalloc or state being Z_NULL). 747 */ 748 749 ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, 750 int level, 751 int strategy)); 752 /* 753 Dynamically update the compression level and compression strategy. The 754 interpretation of level and strategy is as in deflateInit2(). This can be 755 used to switch between compression and straight copy of the input data, or 756 to switch to a different kind of input data requiring a different strategy. 757 If the compression approach (which is a function of the level) or the 758 strategy is changed, and if there have been any deflate() calls since the 759 state was initialized or reset, then the input available so far is 760 compressed with the old level and strategy using deflate(strm, Z_BLOCK). 761 There are three approaches for the compression levels 0, 1..3, and 4..9 762 respectively. The new level and strategy will take effect at the next call 763 of deflate(). 764 765 If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does 766 not have enough output space to complete, then the parameter change will not 767 take effect. In this case, deflateParams() can be called again with the 768 same parameters and more output space to try again. 769 770 In order to assure a change in the parameters on the first try, the 771 deflate stream should be flushed using deflate() with Z_BLOCK or other flush 772 request until strm.avail_out is not zero, before calling deflateParams(). 773 Then no more input data should be provided before the deflateParams() call. 774 If this is done, the old level and strategy will be applied to the data 775 compressed before deflateParams(), and the new level and strategy will be 776 applied to the the data compressed after deflateParams(). 777 778 deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream 779 state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if 780 there was not enough output space to complete the compression of the 781 available input data before a change in the strategy or approach. Note that 782 in the case of a Z_BUF_ERROR, the parameters are not changed. A return 783 value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be 784 retried with more output space. 785 */ 786 787 ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, 788 int good_length, 789 int max_lazy, 790 int nice_length, 791 int max_chain)); 792 /* 793 Fine tune deflate's internal compression parameters. This should only be 794 used by someone who understands the algorithm used by zlib's deflate for 795 searching for the best matching string, and even then only by the most 796 fanatic optimizer trying to squeeze out the last compressed bit for their 797 specific input data. Read the deflate.c source code for the meaning of the 798 max_lazy, good_length, nice_length, and max_chain parameters. 799 800 deflateTune() can be called after deflateInit() or deflateInit2(), and 801 returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. 802 */ 803 804 ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, 805 uLong sourceLen)); 806 /* 807 deflateBound() returns an upper bound on the compressed size after 808 deflation of sourceLen bytes. It must be called after deflateInit() or 809 deflateInit2(), and after deflateSetHeader(), if used. This would be used 810 to allocate an output buffer for deflation in a single pass, and so would be 811 called before deflate(). If that first deflate() call is provided the 812 sourceLen input bytes, an output buffer allocated to the size returned by 813 deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed 814 to return Z_STREAM_END. Note that it is possible for the compressed size to 815 be larger than the value returned by deflateBound() if flush options other 816 than Z_FINISH or Z_NO_FLUSH are used. 817 */ 818 819 ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, 820 unsigned *pending, 821 int *bits)); 822 /* 823 deflatePending() returns the number of bytes and bits of output that have 824 been generated, but not yet provided in the available output. The bytes not 825 provided would be due to the available output space having being consumed. 826 The number of bits of output not provided are between 0 and 7, where they 827 await more bits to join them in order to fill out a full byte. If pending 828 or bits are Z_NULL, then those values are not set. 829 830 deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source 831 stream state was inconsistent. 832 */ 833 834 ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, 835 int bits, 836 int value)); 837 /* 838 deflatePrime() inserts bits in the deflate output stream. The intent 839 is that this function is used to start off the deflate output with the bits 840 leftover from a previous deflate stream when appending to it. As such, this 841 function can only be used for raw deflate, and must be used before the first 842 deflate() call after a deflateInit2() or deflateReset(). bits must be less 843 than or equal to 16, and that many of the least significant bits of value 844 will be inserted in the output. 845 846 deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough 847 room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the 848 source stream state was inconsistent. 849 */ 850 851 ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, 852 gz_headerp head)); 853 /* 854 deflateSetHeader() provides gzip header information for when a gzip 855 stream is requested by deflateInit2(). deflateSetHeader() may be called 856 after deflateInit2() or deflateReset() and before the first call of 857 deflate(). The text, time, os, extra field, name, and comment information 858 in the provided gz_header structure are written to the gzip header (xflag is 859 ignored -- the extra flags are set according to the compression level). The 860 caller must assure that, if not Z_NULL, name and comment are terminated with 861 a zero byte, and that if extra is not Z_NULL, that extra_len bytes are 862 available there. If hcrc is true, a gzip header crc is included. Note that 863 the current versions of the command-line version of gzip (up through version 864 1.3.x) do not support header crc's, and will report that it is a "multi-part 865 gzip file" and give up. 866 867 If deflateSetHeader is not used, the default gzip header has text false, 868 the time set to zero, and os set to 255, with no extra, name, or comment 869 fields. The gzip header is returned to the default state by deflateReset(). 870 871 deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source 872 stream state was inconsistent. 873 */ 874 875 /* 876 ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, 877 int windowBits)); 878 879 This is another version of inflateInit with an extra parameter. The 880 fields next_in, avail_in, zalloc, zfree and opaque must be initialized 881 before by the caller. 882 883 The windowBits parameter is the base two logarithm of the maximum window 884 size (the size of the history buffer). It should be in the range 8..15 for 885 this version of the library. The default value is 15 if inflateInit is used 886 instead. windowBits must be greater than or equal to the windowBits value 887 provided to deflateInit2() while compressing, or it must be equal to 15 if 888 deflateInit2() was not used. If a compressed stream with a larger window 889 size is given as input, inflate() will return with the error code 890 Z_DATA_ERROR instead of trying to allocate a larger window. 891 892 windowBits can also be zero to request that inflate use the window size in 893 the zlib header of the compressed stream. 894 895 windowBits can also be -8..-15 for raw inflate. In this case, -windowBits 896 determines the window size. inflate() will then process raw deflate data, 897 not looking for a zlib or gzip header, not generating a check value, and not 898 looking for any check values for comparison at the end of the stream. This 899 is for use with other formats that use the deflate compressed data format 900 such as zip. Those formats provide their own check values. If a custom 901 format is developed using the raw deflate format for compressed data, it is 902 recommended that a check value such as an Adler-32 or a CRC-32 be applied to 903 the uncompressed data as is done in the zlib, gzip, and zip formats. For 904 most applications, the zlib format should be used as is. Note that comments 905 above on the use in deflateInit2() applies to the magnitude of windowBits. 906 907 windowBits can also be greater than 15 for optional gzip decoding. Add 908 32 to windowBits to enable zlib and gzip decoding with automatic header 909 detection, or add 16 to decode only the gzip format (the zlib format will 910 return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a 911 CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see 912 below), inflate() will *not* automatically decode concatenated gzip members. 913 inflate() will return Z_STREAM_END at the end of the gzip member. The state 914 would need to be reset to continue decoding a subsequent gzip member. This 915 *must* be done if there is more data after a gzip member, in order for the 916 decompression to be compliant with the gzip standard (RFC 1952). 917 918 inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 919 memory, Z_VERSION_ERROR if the zlib library version is incompatible with the 920 version assumed by the caller, or Z_STREAM_ERROR if the parameters are 921 invalid, such as a null pointer to the structure. msg is set to null if 922 there is no error message. inflateInit2 does not perform any decompression 923 apart from possibly reading the zlib header if present: actual decompression 924 will be done by inflate(). (So next_in and avail_in may be modified, but 925 next_out and avail_out are unused and unchanged.) The current implementation 926 of inflateInit2() does not process any header information -- that is 927 deferred until inflate() is called. 928 */ 929 930 ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, 931 const Bytef *dictionary, 932 uInt dictLength)); 933 /* 934 Initializes the decompression dictionary from the given uncompressed byte 935 sequence. This function must be called immediately after a call of inflate, 936 if that call returned Z_NEED_DICT. The dictionary chosen by the compressor 937 can be determined from the Adler-32 value returned by that call of inflate. 938 The compressor and decompressor must use exactly the same dictionary (see 939 deflateSetDictionary). For raw inflate, this function can be called at any 940 time to set the dictionary. If the provided dictionary is smaller than the 941 window and there is already data in the window, then the provided dictionary 942 will amend what's there. The application must insure that the dictionary 943 that was used for compression is provided. 944 945 inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a 946 parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is 947 inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the 948 expected one (incorrect Adler-32 value). inflateSetDictionary does not 949 perform any decompression: this will be done by subsequent calls of 950 inflate(). 951 */ 952 953 #if !defined(__ANDROID__) || __ANDROID_API__ >= 19 954 ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, 955 Bytef *dictionary, 956 uInt *dictLength)); 957 #endif 958 /* 959 Returns the sliding dictionary being maintained by inflate. dictLength is 960 set to the number of bytes in the dictionary, and that many bytes are copied 961 to dictionary. dictionary must have enough space, where 32768 bytes is 962 always enough. If inflateGetDictionary() is called with dictionary equal to 963 Z_NULL, then only the dictionary length is returned, and nothing is copied. 964 Similarly, if dictLength is Z_NULL, then it is not set. 965 966 inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the 967 stream state is inconsistent. 968 */ 969 970 ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); 971 /* 972 Skips invalid compressed data until a possible full flush point (see above 973 for the description of deflate with Z_FULL_FLUSH) can be found, or until all 974 available input is skipped. No output is provided. 975 976 inflateSync searches for a 00 00 FF FF pattern in the compressed data. 977 All full flush points have this pattern, but not all occurrences of this 978 pattern are full flush points. 979 980 inflateSync returns Z_OK if a possible full flush point has been found, 981 Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point 982 has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. 983 In the success case, the application may save the current current value of 984 total_in which indicates where valid compressed data was found. In the 985 error case, the application may repeatedly call inflateSync, providing more 986 input each time, until success or end of the input data. 987 */ 988 989 ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, 990 z_streamp source)); 991 /* 992 Sets the destination stream as a complete copy of the source stream. 993 994 This function can be useful when randomly accessing a large stream. The 995 first pass through the stream can periodically record the inflate state, 996 allowing restarting inflate at those points when randomly accessing the 997 stream. 998 999 inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not 1000 enough memory, Z_STREAM_ERROR if the source stream state was inconsistent 1001 (such as zalloc being Z_NULL). msg is left unchanged in both source and 1002 destination. 1003 */ 1004 1005 ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); 1006 /* 1007 This function is equivalent to inflateEnd followed by inflateInit, 1008 but does not free and reallocate the internal decompression state. The 1009 stream will keep attributes that may have been set by inflateInit2. 1010 1011 inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source 1012 stream state was inconsistent (such as zalloc or state being Z_NULL). 1013 */ 1014 1015 ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, 1016 int windowBits)); 1017 /* 1018 This function is the same as inflateReset, but it also permits changing 1019 the wrap and window size requests. The windowBits parameter is interpreted 1020 the same as it is for inflateInit2. If the window size is changed, then the 1021 memory allocated for the window is freed, and the window will be reallocated 1022 by inflate() if needed. 1023 1024 inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source 1025 stream state was inconsistent (such as zalloc or state being Z_NULL), or if 1026 the windowBits parameter is invalid. 1027 */ 1028 1029 ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, 1030 int bits, 1031 int value)); 1032 /* 1033 This function inserts bits in the inflate input stream. The intent is 1034 that this function is used to start inflating at a bit position in the 1035 middle of a byte. The provided bits will be used before any bytes are used 1036 from next_in. This function should only be used with raw inflate, and 1037 should be used before the first inflate() call after inflateInit2() or 1038 inflateReset(). bits must be less than or equal to 16, and that many of the 1039 least significant bits of value will be inserted in the input. 1040 1041 If bits is negative, then the input stream bit buffer is emptied. Then 1042 inflatePrime() can be called again to put bits in the buffer. This is used 1043 to clear out bits leftover after feeding inflate a block description prior 1044 to feeding inflate codes. 1045 1046 inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source 1047 stream state was inconsistent. 1048 */ 1049 1050 ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); 1051 /* 1052 This function returns two values, one in the lower 16 bits of the return 1053 value, and the other in the remaining upper bits, obtained by shifting the 1054 return value down 16 bits. If the upper value is -1 and the lower value is 1055 zero, then inflate() is currently decoding information outside of a block. 1056 If the upper value is -1 and the lower value is non-zero, then inflate is in 1057 the middle of a stored block, with the lower value equaling the number of 1058 bytes from the input remaining to copy. If the upper value is not -1, then 1059 it is the number of bits back from the current bit position in the input of 1060 the code (literal or length/distance pair) currently being processed. In 1061 that case the lower value is the number of bytes already emitted for that 1062 code. 1063 1064 A code is being processed if inflate is waiting for more input to complete 1065 decoding of the code, or if it has completed decoding but is waiting for 1066 more output space to write the literal or match data. 1067 1068 inflateMark() is used to mark locations in the input data for random 1069 access, which may be at bit positions, and to note those cases where the 1070 output of a code may span boundaries of random access blocks. The current 1071 location in the input stream can be determined from avail_in and data_type 1072 as noted in the description for the Z_BLOCK flush parameter for inflate. 1073 1074 inflateMark returns the value noted above, or -65536 if the provided 1075 source stream state was inconsistent. 1076 */ 1077 1078 ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, 1079 gz_headerp head)); 1080 /* 1081 inflateGetHeader() requests that gzip header information be stored in the 1082 provided gz_header structure. inflateGetHeader() may be called after 1083 inflateInit2() or inflateReset(), and before the first call of inflate(). 1084 As inflate() processes the gzip stream, head->done is zero until the header 1085 is completed, at which time head->done is set to one. If a zlib stream is 1086 being decoded, then head->done is set to -1 to indicate that there will be 1087 no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be 1088 used to force inflate() to return immediately after header processing is 1089 complete and before any actual data is decompressed. 1090 1091 The text, time, xflags, and os fields are filled in with the gzip header 1092 contents. hcrc is set to true if there is a header CRC. (The header CRC 1093 was valid if done is set to one.) If extra is not Z_NULL, then extra_max 1094 contains the maximum number of bytes to write to extra. Once done is true, 1095 extra_len contains the actual extra field length, and extra contains the 1096 extra field, or that field truncated if extra_max is less than extra_len. 1097 If name is not Z_NULL, then up to name_max characters are written there, 1098 terminated with a zero unless the length is greater than name_max. If 1099 comment is not Z_NULL, then up to comm_max characters are written there, 1100 terminated with a zero unless the length is greater than comm_max. When any 1101 of extra, name, or comment are not Z_NULL and the respective field is not 1102 present in the header, then that field is set to Z_NULL to signal its 1103 absence. This allows the use of deflateSetHeader() with the returned 1104 structure to duplicate the header. However if those fields are set to 1105 allocated memory, then the application will need to save those pointers 1106 elsewhere so that they can be eventually freed. 1107 1108 If inflateGetHeader is not used, then the header information is simply 1109 discarded. The header is always checked for validity, including the header 1110 CRC if present. inflateReset() will reset the process to discard the header 1111 information. The application would need to call inflateGetHeader() again to 1112 retrieve the header from the next gzip stream. 1113 1114 inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source 1115 stream state was inconsistent. 1116 */ 1117 1118 /* 1119 ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, 1120 unsigned char FAR *window)); 1121 1122 Initialize the internal stream state for decompression using inflateBack() 1123 calls. The fields zalloc, zfree and opaque in strm must be initialized 1124 before the call. If zalloc and zfree are Z_NULL, then the default library- 1125 derived memory allocation routines are used. windowBits is the base two 1126 logarithm of the window size, in the range 8..15. window is a caller 1127 supplied buffer of that size. Except for special applications where it is 1128 assured that deflate was used with small window sizes, windowBits must be 15 1129 and a 32K byte window must be supplied to be able to decompress general 1130 deflate streams. 1131 1132 See inflateBack() for the usage of these routines. 1133 1134 inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of 1135 the parameters are invalid, Z_MEM_ERROR if the internal state could not be 1136 allocated, or Z_VERSION_ERROR if the version of the library does not match 1137 the version of the header file. 1138 */ 1139 1140 typedef unsigned (*in_func) OF((void FAR *, 1141 z_const unsigned char FAR * FAR *)); 1142 typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); 1143 1144 ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, 1145 in_func in, void FAR *in_desc, 1146 out_func out, void FAR *out_desc)); 1147 /* 1148 inflateBack() does a raw inflate with a single call using a call-back 1149 interface for input and output. This is potentially more efficient than 1150 inflate() for file i/o applications, in that it avoids copying between the 1151 output and the sliding window by simply making the window itself the output 1152 buffer. inflate() can be faster on modern CPUs when used with large 1153 buffers. inflateBack() trusts the application to not change the output 1154 buffer passed by the output function, at least until inflateBack() returns. 1155 1156 inflateBackInit() must be called first to allocate the internal state 1157 and to initialize the state with the user-provided window buffer. 1158 inflateBack() may then be used multiple times to inflate a complete, raw 1159 deflate stream with each call. inflateBackEnd() is then called to free the 1160 allocated state. 1161 1162 A raw deflate stream is one with no zlib or gzip header or trailer. 1163 This routine would normally be used in a utility that reads zip or gzip 1164 files and writes out uncompressed files. The utility would decode the 1165 header and process the trailer on its own, hence this routine expects only 1166 the raw deflate stream to decompress. This is different from the default 1167 behavior of inflate(), which expects a zlib header and trailer around the 1168 deflate stream. 1169 1170 inflateBack() uses two subroutines supplied by the caller that are then 1171 called by inflateBack() for input and output. inflateBack() calls those 1172 routines until it reads a complete deflate stream and writes out all of the 1173 uncompressed data, or until it encounters an error. The function's 1174 parameters and return types are defined above in the in_func and out_func 1175 typedefs. inflateBack() will call in(in_desc, &buf) which should return the 1176 number of bytes of provided input, and a pointer to that input in buf. If 1177 there is no input available, in() must return zero -- buf is ignored in that 1178 case -- and inflateBack() will return a buffer error. inflateBack() will 1179 call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. 1180 out() should return zero on success, or non-zero on failure. If out() 1181 returns non-zero, inflateBack() will return with an error. Neither in() nor 1182 out() are permitted to change the contents of the window provided to 1183 inflateBackInit(), which is also the buffer that out() uses to write from. 1184 The length written by out() will be at most the window size. Any non-zero 1185 amount of input may be provided by in(). 1186 1187 For convenience, inflateBack() can be provided input on the first call by 1188 setting strm->next_in and strm->avail_in. If that input is exhausted, then 1189 in() will be called. Therefore strm->next_in must be initialized before 1190 calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called 1191 immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in 1192 must also be initialized, and then if strm->avail_in is not zero, input will 1193 initially be taken from strm->next_in[0 .. strm->avail_in - 1]. 1194 1195 The in_desc and out_desc parameters of inflateBack() is passed as the 1196 first parameter of in() and out() respectively when they are called. These 1197 descriptors can be optionally used to pass any information that the caller- 1198 supplied in() and out() functions need to do their job. 1199 1200 On return, inflateBack() will set strm->next_in and strm->avail_in to 1201 pass back any unused input that was provided by the last in() call. The 1202 return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR 1203 if in() or out() returned an error, Z_DATA_ERROR if there was a format error 1204 in the deflate stream (in which case strm->msg is set to indicate the nature 1205 of the error), or Z_STREAM_ERROR if the stream was not properly initialized. 1206 In the case of Z_BUF_ERROR, an input or output error can be distinguished 1207 using strm->next_in which will be Z_NULL only if in() returned an error. If 1208 strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning 1209 non-zero. (in() will always be called before out(), so strm->next_in is 1210 assured to be defined if out() returns non-zero.) Note that inflateBack() 1211 cannot return Z_OK. 1212 */ 1213 1214 ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); 1215 /* 1216 All memory allocated by inflateBackInit() is freed. 1217 1218 inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream 1219 state was inconsistent. 1220 */ 1221 1222 ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); 1223 /* Return flags indicating compile-time options. 1224 1225 Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: 1226 1.0: size of uInt 1227 3.2: size of uLong 1228 5.4: size of voidpf (pointer) 1229 7.6: size of z_off_t 1230 1231 Compiler, assembler, and debug options: 1232 8: ZLIB_DEBUG 1233 9: ASMV or ASMINF -- use ASM code 1234 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention 1235 11: 0 (reserved) 1236 1237 One-time table building (smaller code, but not thread-safe if true): 1238 12: BUILDFIXED -- build static block decoding tables when needed 1239 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed 1240 14,15: 0 (reserved) 1241 1242 Library content (indicates missing functionality): 1243 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking 1244 deflate code when not needed) 1245 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect 1246 and decode gzip streams (to avoid linking crc code) 1247 18-19: 0 (reserved) 1248 1249 Operation variations (changes in library functionality): 1250 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate 1251 21: FASTEST -- deflate algorithm with only one, lowest compression level 1252 22,23: 0 (reserved) 1253 1254 The sprintf variant used by gzprintf (zero is best): 1255 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format 1256 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! 1257 26: 0 = returns value, 1 = void -- 1 means inferred string length returned 1258 1259 Remainder: 1260 27-31: 0 (reserved) 1261 */ 1262 1263 #ifndef Z_SOLO 1264 1265 /* utility functions */ 1266 1267 /* 1268 The following utility functions are implemented on top of the basic 1269 stream-oriented functions. To simplify the interface, some default options 1270 are assumed (compression level and memory usage, standard memory allocation 1271 functions). The source code of these utility functions can be modified if 1272 you need special options. 1273 */ 1274 1275 ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, 1276 const Bytef *source, uLong sourceLen)); 1277 /* 1278 Compresses the source buffer into the destination buffer. sourceLen is 1279 the byte length of the source buffer. Upon entry, destLen is the total size 1280 of the destination buffer, which must be at least the value returned by 1281 compressBound(sourceLen). Upon exit, destLen is the actual size of the 1282 compressed data. compress() is equivalent to compress2() with a level 1283 parameter of Z_DEFAULT_COMPRESSION. 1284 1285 compress returns Z_OK if success, Z_MEM_ERROR if there was not 1286 enough memory, Z_BUF_ERROR if there was not enough room in the output 1287 buffer. 1288 */ 1289 1290 ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, 1291 const Bytef *source, uLong sourceLen, 1292 int level)); 1293 /* 1294 Compresses the source buffer into the destination buffer. The level 1295 parameter has the same meaning as in deflateInit. sourceLen is the byte 1296 length of the source buffer. Upon entry, destLen is the total size of the 1297 destination buffer, which must be at least the value returned by 1298 compressBound(sourceLen). Upon exit, destLen is the actual size of the 1299 compressed data. 1300 1301 compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 1302 memory, Z_BUF_ERROR if there was not enough room in the output buffer, 1303 Z_STREAM_ERROR if the level parameter is invalid. 1304 */ 1305 1306 ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); 1307 /* 1308 compressBound() returns an upper bound on the compressed size after 1309 compress() or compress2() on sourceLen bytes. It would be used before a 1310 compress() or compress2() call to allocate the destination buffer. 1311 */ 1312 1313 ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, 1314 const Bytef *source, uLong sourceLen)); 1315 /* 1316 Decompresses the source buffer into the destination buffer. sourceLen is 1317 the byte length of the source buffer. Upon entry, destLen is the total size 1318 of the destination buffer, which must be large enough to hold the entire 1319 uncompressed data. (The size of the uncompressed data must have been saved 1320 previously by the compressor and transmitted to the decompressor by some 1321 mechanism outside the scope of this compression library.) Upon exit, destLen 1322 is the actual size of the uncompressed data. 1323 1324 uncompress returns Z_OK if success, Z_MEM_ERROR if there was not 1325 enough memory, Z_BUF_ERROR if there was not enough room in the output 1326 buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In 1327 the case where there is not enough room, uncompress() will fill the output 1328 buffer with the uncompressed data up to that point. 1329 */ 1330 1331 #if !defined(__ANDROID__) || __ANDROID_API__ >= 28 1332 ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen, 1333 const Bytef *source, uLong *sourceLen)); 1334 #endif 1335 /* 1336 Same as uncompress, except that sourceLen is a pointer, where the 1337 length of the source is *sourceLen. On return, *sourceLen is the number of 1338 source bytes consumed. 1339 */ 1340 1341 /* gzip file access functions */ 1342 1343 /* 1344 This library supports reading and writing files in gzip (.gz) format with 1345 an interface similar to that of stdio, using the functions that start with 1346 "gz". The gzip format is different from the zlib format. gzip is a gzip 1347 wrapper, documented in RFC 1952, wrapped around a deflate stream. 1348 */ 1349 1350 typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ 1351 1352 /* 1353 ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); 1354 1355 Open the gzip (.gz) file at path for reading and decompressing, or 1356 compressing and writing. The mode parameter is as in fopen ("rb" or "wb") 1357 but can also include a compression level ("wb9") or a strategy: 'f' for 1358 filtered data as in "wb6f", 'h' for Huffman-only compression as in "wb1h", 1359 'R' for run-length encoding as in "wb1R", or 'F' for fixed code compression 1360 as in "wb9F". (See the description of deflateInit2 for more information 1361 about the strategy parameter.) 'T' will request transparent writing or 1362 appending with no compression and not using the gzip format. 1363 1364 "a" can be used instead of "w" to request that the gzip stream that will 1365 be written be appended to the file. "+" will result in an error, since 1366 reading and writing to the same gzip file is not supported. The addition of 1367 "x" when writing will create the file exclusively, which fails if the file 1368 already exists. On systems that support it, the addition of "e" when 1369 reading or writing will set the flag to close the file on an execve() call. 1370 1371 These functions, as well as gzip, will read and decode a sequence of gzip 1372 streams in a file. The append function of gzopen() can be used to create 1373 such a file. (Also see gzflush() for another way to do this.) When 1374 appending, gzopen does not test whether the file begins with a gzip stream, 1375 nor does it look for the end of the gzip streams to begin appending. gzopen 1376 will simply append a gzip stream to the existing file. 1377 1378 gzopen can be used to read a file which is not in gzip format; in this 1379 case gzread will directly read from the file without decompression. When 1380 reading, this will be detected automatically by looking for the magic two- 1381 byte gzip header. 1382 1383 gzopen returns NULL if the file could not be opened, if there was 1384 insufficient memory to allocate the gzFile state, or if an invalid mode was 1385 specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). 1386 errno can be checked to determine if the reason gzopen failed was that the 1387 file could not be opened. 1388 */ 1389 1390 ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); 1391 /* 1392 Associate a gzFile with the file descriptor fd. File descriptors are 1393 obtained from calls like open, dup, creat, pipe or fileno (if the file has 1394 been previously opened with fopen). The mode parameter is as in gzopen. 1395 1396 The next call of gzclose on the returned gzFile will also close the file 1397 descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor 1398 fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, 1399 mode);. The duplicated descriptor should be saved to avoid a leak, since 1400 gzdopen does not close fd if it fails. If you are using fileno() to get the 1401 file descriptor from a FILE *, then you will have to use dup() to avoid 1402 double-close()ing the file descriptor. Both gzclose() and fclose() will 1403 close the associated file descriptor, so they need to have different file 1404 descriptors. 1405 1406 gzdopen returns NULL if there was insufficient memory to allocate the 1407 gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not 1408 provided, or '+' was provided), or if fd is -1. The file descriptor is not 1409 used until the next gz* read, write, seek, or close operation, so gzdopen 1410 will not detect if fd is invalid (unless fd is -1). 1411 */ 1412 1413 ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); 1414 /* 1415 Set the internal buffer size used by this library's functions for file to 1416 size. The default buffer size is 8192 bytes. This function must be called 1417 after gzopen() or gzdopen(), and before any other calls that read or write 1418 the file. The buffer memory allocation is always deferred to the first read 1419 or write. Three times that size in buffer space is allocated. A larger 1420 buffer size of, for example, 64K or 128K bytes will noticeably increase the 1421 speed of decompression (reading). 1422 1423 The new buffer size also affects the maximum length for gzprintf(). 1424 1425 gzbuffer() returns 0 on success, or -1 on failure, such as being called 1426 too late. 1427 */ 1428 1429 ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); 1430 /* 1431 Dynamically update the compression level and strategy for file. See the 1432 description of deflateInit2 for the meaning of these parameters. Previously 1433 provided data is flushed before applying the parameter changes. 1434 1435 gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not 1436 opened for writing, Z_ERRNO if there is an error writing the flushed data, 1437 or Z_MEM_ERROR if there is a memory allocation error. 1438 */ 1439 1440 ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); 1441 /* 1442 Read and decompress up to len uncompressed bytes from file into buf. If 1443 the input file is not in gzip format, gzread copies the given number of 1444 bytes into the buffer directly from the file. 1445 1446 After reaching the end of a gzip stream in the input, gzread will continue 1447 to read, looking for another gzip stream. Any number of gzip streams may be 1448 concatenated in the input file, and will all be decompressed by gzread(). 1449 If something other than a gzip stream is encountered after a gzip stream, 1450 that remaining trailing garbage is ignored (and no error is returned). 1451 1452 gzread can be used to read a gzip file that is being concurrently written. 1453 Upon reaching the end of the input, gzread will return with the available 1454 data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then 1455 gzclearerr can be used to clear the end of file indicator in order to permit 1456 gzread to be tried again. Z_OK indicates that a gzip stream was completed 1457 on the last gzread. Z_BUF_ERROR indicates that the input file ended in the 1458 middle of a gzip stream. Note that gzread does not return -1 in the event 1459 of an incomplete gzip stream. This error is deferred until gzclose(), which 1460 will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip 1461 stream. Alternatively, gzerror can be used before gzclose to detect this 1462 case. 1463 1464 gzread returns the number of uncompressed bytes actually read, less than 1465 len for end of file, or -1 for error. If len is too large to fit in an int, 1466 then nothing is read, -1 is returned, and the error state is set to 1467 Z_STREAM_ERROR. 1468 */ 1469 1470 #if !defined(__ANDROID__) || __ANDROID_API__ >= 28 1471 ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems, 1472 gzFile file)); 1473 #endif 1474 /* 1475 Read and decompress up to nitems items of size size from file into buf, 1476 otherwise operating as gzread() does. This duplicates the interface of 1477 stdio's fread(), with size_t request and return types. If the library 1478 defines size_t, then z_size_t is identical to size_t. If not, then z_size_t 1479 is an unsigned integer type that can contain a pointer. 1480 1481 gzfread() returns the number of full items read of size size, or zero if 1482 the end of the file was reached and a full item could not be read, or if 1483 there was an error. gzerror() must be consulted if zero is returned in 1484 order to determine if there was an error. If the multiplication of size and 1485 nitems overflows, i.e. the product does not fit in a z_size_t, then nothing 1486 is read, zero is returned, and the error state is set to Z_STREAM_ERROR. 1487 1488 In the event that the end of file is reached and only a partial item is 1489 available at the end, i.e. the remaining uncompressed data length is not a 1490 multiple of size, then the final partial item is nevertheless read into buf 1491 and the end-of-file flag is set. The length of the partial item read is not 1492 provided, but could be inferred from the result of gztell(). This behavior 1493 is the same as the behavior of fread() implementations in common libraries, 1494 but it prevents the direct use of gzfread() to read a concurrently written 1495 file, resetting and retrying on end-of-file, when size is not 1. 1496 */ 1497 1498 ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len)); 1499 /* 1500 Compress and write the len uncompressed bytes at buf to file. gzwrite 1501 returns the number of uncompressed bytes written or 0 in case of error. 1502 */ 1503 1504 #if !defined(__ANDROID__) || __ANDROID_API__ >= 28 1505 ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size, 1506 z_size_t nitems, gzFile file)); 1507 #endif 1508 /* 1509 Compress and write nitems items of size size from buf to file, duplicating 1510 the interface of stdio's fwrite(), with size_t request and return types. If 1511 the library defines size_t, then z_size_t is identical to size_t. If not, 1512 then z_size_t is an unsigned integer type that can contain a pointer. 1513 1514 gzfwrite() returns the number of full items written of size size, or zero 1515 if there was an error. If the multiplication of size and nitems overflows, 1516 i.e. the product does not fit in a z_size_t, then nothing is written, zero 1517 is returned, and the error state is set to Z_STREAM_ERROR. 1518 */ 1519 1520 ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); 1521 /* 1522 Convert, format, compress, and write the arguments (...) to file under 1523 control of the string format, as in fprintf. gzprintf returns the number of 1524 uncompressed bytes actually written, or a negative zlib error code in case 1525 of error. The number of uncompressed bytes written is limited to 8191, or 1526 one less than the buffer size given to gzbuffer(). The caller should assure 1527 that this limit is not exceeded. If it is exceeded, then gzprintf() will 1528 return an error (0) with nothing written. In this case, there may also be a 1529 buffer overflow with unpredictable consequences, which is possible only if 1530 zlib was compiled with the insecure functions sprintf() or vsprintf(), 1531 because the secure snprintf() or vsnprintf() functions were not available. 1532 This can be determined using zlibCompileFlags(). 1533 */ 1534 1535 ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); 1536 /* 1537 Compress and write the given null-terminated string s to file, excluding 1538 the terminating null character. 1539 1540 gzputs returns the number of characters written, or -1 in case of error. 1541 */ 1542 1543 ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); 1544 /* 1545 Read and decompress bytes from file into buf, until len-1 characters are 1546 read, or until a newline character is read and transferred to buf, or an 1547 end-of-file condition is encountered. If any characters are read or if len 1548 is one, the string is terminated with a null character. If no characters 1549 are read due to an end-of-file or len is less than one, then the buffer is 1550 left untouched. 1551 1552 gzgets returns buf which is a null-terminated string, or it returns NULL 1553 for end-of-file or in case of error. If there was an error, the contents at 1554 buf are indeterminate. 1555 */ 1556 1557 ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); 1558 /* 1559 Compress and write c, converted to an unsigned char, into file. gzputc 1560 returns the value that was written, or -1 in case of error. 1561 */ 1562 1563 ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); 1564 /* 1565 Read and decompress one byte from file. gzgetc returns this byte or -1 1566 in case of end of file or error. This is implemented as a macro for speed. 1567 As such, it does not do all of the checking the other functions do. I.e. 1568 it does not check to see if file is NULL, nor whether the structure file 1569 points to has been clobbered or not. 1570 */ 1571 1572 ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); 1573 /* 1574 Push c back onto the stream for file to be read as the first character on 1575 the next read. At least one character of push-back is always allowed. 1576 gzungetc() returns the character pushed, or -1 on failure. gzungetc() will 1577 fail if c is -1, and may fail if a character has been pushed but not read 1578 yet. If gzungetc is used immediately after gzopen or gzdopen, at least the 1579 output buffer size of pushed characters is allowed. (See gzbuffer above.) 1580 The pushed character will be discarded if the stream is repositioned with 1581 gzseek() or gzrewind(). 1582 */ 1583 1584 ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); 1585 /* 1586 Flush all pending output to file. The parameter flush is as in the 1587 deflate() function. The return value is the zlib error number (see function 1588 gzerror below). gzflush is only permitted when writing. 1589 1590 If the flush parameter is Z_FINISH, the remaining data is written and the 1591 gzip stream is completed in the output. If gzwrite() is called again, a new 1592 gzip stream will be started in the output. gzread() is able to read such 1593 concatenated gzip streams. 1594 1595 gzflush should be called only when strictly necessary because it will 1596 degrade compression if called too often. 1597 */ 1598 1599 /* 1600 ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, 1601 z_off_t offset, int whence)); 1602 1603 Set the starting position to offset relative to whence for the next gzread 1604 or gzwrite on file. The offset represents a number of bytes in the 1605 uncompressed data stream. The whence parameter is defined as in lseek(2); 1606 the value SEEK_END is not supported. 1607 1608 If the file is opened for reading, this function is emulated but can be 1609 extremely slow. If the file is opened for writing, only forward seeks are 1610 supported; gzseek then compresses a sequence of zeroes up to the new 1611 starting position. 1612 1613 gzseek returns the resulting offset location as measured in bytes from 1614 the beginning of the uncompressed stream, or -1 in case of error, in 1615 particular if the file is opened for writing and the new starting position 1616 would be before the current position. 1617 */ 1618 1619 ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); 1620 /* 1621 Rewind file. This function is supported only for reading. 1622 1623 gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET). 1624 */ 1625 1626 /* 1627 ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); 1628 1629 Return the starting position for the next gzread or gzwrite on file. 1630 This position represents a number of bytes in the uncompressed data stream, 1631 and is zero when starting, even if appending or reading a gzip stream from 1632 the middle of a file using gzdopen(). 1633 1634 gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) 1635 */ 1636 1637 /* 1638 ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); 1639 1640 Return the current compressed (actual) read or write offset of file. This 1641 offset includes the count of bytes that precede the gzip stream, for example 1642 when appending or when using gzdopen() for reading. When reading, the 1643 offset does not include as yet unused buffered input. This information can 1644 be used for a progress indicator. On error, gzoffset() returns -1. 1645 */ 1646 1647 ZEXTERN int ZEXPORT gzeof OF((gzFile file)); 1648 /* 1649 Return true (1) if the end-of-file indicator for file has been set while 1650 reading, false (0) otherwise. Note that the end-of-file indicator is set 1651 only if the read tried to go past the end of the input, but came up short. 1652 Therefore, just like feof(), gzeof() may return false even if there is no 1653 more data to read, in the event that the last read request was for the exact 1654 number of bytes remaining in the input file. This will happen if the input 1655 file size is an exact multiple of the buffer size. 1656 1657 If gzeof() returns true, then the read functions will return no more data, 1658 unless the end-of-file indicator is reset by gzclearerr() and the input file 1659 has grown since the previous end of file was detected. 1660 */ 1661 1662 ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); 1663 /* 1664 Return true (1) if file is being copied directly while reading, or false 1665 (0) if file is a gzip stream being decompressed. 1666 1667 If the input file is empty, gzdirect() will return true, since the input 1668 does not contain a gzip stream. 1669 1670 If gzdirect() is used immediately after gzopen() or gzdopen() it will 1671 cause buffers to be allocated to allow reading the file to determine if it 1672 is a gzip file. Therefore if gzbuffer() is used, it should be called before 1673 gzdirect(). 1674 1675 When writing, gzdirect() returns true (1) if transparent writing was 1676 requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: 1677 gzdirect() is not needed when writing. Transparent writing must be 1678 explicitly requested, so the application already knows the answer. When 1679 linking statically, using gzdirect() will include all of the zlib code for 1680 gzip file reading and decompression, which may not be desired.) 1681 */ 1682 1683 ZEXTERN int ZEXPORT gzclose OF((gzFile file)); 1684 /* 1685 Flush all pending output for file, if necessary, close file and 1686 deallocate the (de)compression state. Note that once file is closed, you 1687 cannot call gzerror with file, since its structures have been deallocated. 1688 gzclose must not be called more than once on the same file, just as free 1689 must not be called more than once on the same allocation. 1690 1691 gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a 1692 file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the 1693 last read ended in the middle of a gzip stream, or Z_OK on success. 1694 */ 1695 1696 ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); 1697 ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); 1698 /* 1699 Same as gzclose(), but gzclose_r() is only for use when reading, and 1700 gzclose_w() is only for use when writing or appending. The advantage to 1701 using these instead of gzclose() is that they avoid linking in zlib 1702 compression or decompression code that is not used when only reading or only 1703 writing respectively. If gzclose() is used, then both compression and 1704 decompression code will be included the application when linking to a static 1705 zlib library. 1706 */ 1707 1708 ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); 1709 /* 1710 Return the error message for the last error which occurred on file. 1711 errnum is set to zlib error number. If an error occurred in the file system 1712 and not in the compression library, errnum is set to Z_ERRNO and the 1713 application may consult errno to get the exact error code. 1714 1715 The application must not modify the returned string. Future calls to 1716 this function may invalidate the previously returned string. If file is 1717 closed, then the string previously returned by gzerror will no longer be 1718 available. 1719 1720 gzerror() should be used to distinguish errors from end-of-file for those 1721 functions above that do not distinguish those cases in their return values. 1722 */ 1723 1724 ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); 1725 /* 1726 Clear the error and end-of-file flags for file. This is analogous to the 1727 clearerr() function in stdio. This is useful for continuing to read a gzip 1728 file that is being written concurrently. 1729 */ 1730 1731 #endif /* !Z_SOLO */ 1732 1733 /* checksum functions */ 1734 1735 /* 1736 These functions are not related to compression but are exported 1737 anyway because they might be useful in applications using the compression 1738 library. 1739 */ 1740 1741 ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); 1742 /* 1743 Update a running Adler-32 checksum with the bytes buf[0..len-1] and 1744 return the updated checksum. An Adler-32 value is in the range of a 32-bit 1745 unsigned integer. If buf is Z_NULL, this function returns the required 1746 initial value for the checksum. 1747 1748 An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed 1749 much faster. 1750 1751 Usage example: 1752 1753 uLong adler = adler32(0L, Z_NULL, 0); 1754 1755 while (read_buffer(buffer, length) != EOF) { 1756 adler = adler32(adler, buffer, length); 1757 } 1758 if (adler != original_adler) error(); 1759 */ 1760 1761 #if !defined(__ANDROID__) || __ANDROID_API__ >= 28 1762 ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf, 1763 z_size_t len)); 1764 #endif 1765 /* 1766 Same as adler32(), but with a size_t length. 1767 */ 1768 1769 /* 1770 ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, 1771 z_off_t len2)); 1772 1773 Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 1774 and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for 1775 each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of 1776 seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note 1777 that the z_off_t type (like off_t) is a signed integer. If len2 is 1778 negative, the result has no meaning or utility. 1779 */ 1780 1781 ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); 1782 /* 1783 Update a running CRC-32 with the bytes buf[0..len-1] and return the 1784 updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer. 1785 If buf is Z_NULL, this function returns the required initial value for the 1786 crc. Pre- and post-conditioning (one's complement) is performed within this 1787 function so it shouldn't be done by the application. 1788 1789 Usage example: 1790 1791 uLong crc = crc32(0L, Z_NULL, 0); 1792 1793 while (read_buffer(buffer, length) != EOF) { 1794 crc = crc32(crc, buffer, length); 1795 } 1796 if (crc != original_crc) error(); 1797 */ 1798 1799 #if !defined(__ANDROID__) || __ANDROID_API__ >= 28 1800 ZEXTERN uLong ZEXPORT crc32_z OF((uLong crc, const Bytef *buf, 1801 z_size_t len)); 1802 #endif 1803 /* 1804 Same as crc32(), but with a size_t length. 1805 */ 1806 1807 /* 1808 ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); 1809 1810 Combine two CRC-32 check values into one. For two sequences of bytes, 1811 seq1 and seq2 with lengths len1 and len2, CRC-32 check values were 1812 calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 1813 check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and 1814 len2. 1815 */ 1816 1817 /* 1818 ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t len2)); 1819 1820 Return the operator corresponding to length len2, to be used with 1821 crc32_combine_op(). 1822 */ 1823 1824 ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op)); 1825 /* 1826 Give the same result as crc32_combine(), using op in place of len2. op is 1827 is generated from len2 by crc32_combine_gen(). This will be faster than 1828 crc32_combine() if the generated op is used more than once. 1829 */ 1830 1831 1832 /* various hacks, don't look :) */ 1833 1834 /* deflateInit and inflateInit are macros to allow checking the zlib version 1835 * and the compiler's view of z_stream: 1836 */ 1837 ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, 1838 const char *version, int stream_size)); 1839 ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, 1840 const char *version, int stream_size)); 1841 ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, 1842 int windowBits, int memLevel, 1843 int strategy, const char *version, 1844 int stream_size)); 1845 ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, 1846 const char *version, int stream_size)); 1847 ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, 1848 unsigned char FAR *window, 1849 const char *version, 1850 int stream_size)); 1851 #ifdef Z_PREFIX_SET 1852 # define z_deflateInit(strm, level) \ 1853 deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) 1854 # define z_inflateInit(strm) \ 1855 inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) 1856 # define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ 1857 deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ 1858 (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) 1859 # define z_inflateInit2(strm, windowBits) \ 1860 inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ 1861 (int)sizeof(z_stream)) 1862 # define z_inflateBackInit(strm, windowBits, window) \ 1863 inflateBackInit_((strm), (windowBits), (window), \ 1864 ZLIB_VERSION, (int)sizeof(z_stream)) 1865 #else 1866 # define deflateInit(strm, level) \ 1867 deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) 1868 # define inflateInit(strm) \ 1869 inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) 1870 # define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ 1871 deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ 1872 (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) 1873 # define inflateInit2(strm, windowBits) \ 1874 inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ 1875 (int)sizeof(z_stream)) 1876 # define inflateBackInit(strm, windowBits, window) \ 1877 inflateBackInit_((strm), (windowBits), (window), \ 1878 ZLIB_VERSION, (int)sizeof(z_stream)) 1879 #endif 1880 1881 #ifndef Z_SOLO 1882 1883 /* gzgetc() macro and its supporting function and exposed data structure. Note 1884 * that the real internal state is much larger than the exposed structure. 1885 * This abbreviated structure exposes just enough for the gzgetc() macro. The 1886 * user should not mess with these exposed elements, since their names or 1887 * behavior could change in the future, perhaps even capriciously. They can 1888 * only be used by the gzgetc() macro. You have been warned. 1889 */ 1890 struct gzFile_s { 1891 unsigned have; 1892 unsigned char *next; 1893 z_off64_t pos; 1894 }; 1895 ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ 1896 #ifdef Z_PREFIX_SET 1897 # undef z_gzgetc 1898 # define z_gzgetc(g) \ 1899 ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) 1900 #elif defined(Z_CR_PREFIX_SET) 1901 # undef gzgetc 1902 # define gzgetc(g) \ 1903 ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) \ 1904 : (Cr_z_gzgetc)(g)) 1905 #else 1906 # define gzgetc(g) \ 1907 ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) 1908 #endif 1909 1910 /* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or 1911 * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if 1912 * both are true, the application gets the *64 functions, and the regular 1913 * functions are changed to 64 bits) -- in case these are set on systems 1914 * without large file support, _LFS64_LARGEFILE must also be true 1915 */ 1916 #ifdef Z_LARGE64 1917 ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); 1918 ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); 1919 ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); 1920 ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); 1921 ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); 1922 ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); 1923 ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off64_t)); 1924 #endif 1925 1926 #if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) 1927 # ifdef Z_PREFIX_SET 1928 # define z_gzopen z_gzopen64 1929 # define z_gzseek z_gzseek64 1930 # define z_gztell z_gztell64 1931 # define z_gzoffset z_gzoffset64 1932 # define z_adler32_combine z_adler32_combine64 1933 # define z_crc32_combine z_crc32_combine64 1934 # define z_crc32_combine_gen z_crc32_combine_gen64 1935 # else 1936 # ifdef gzopen 1937 # undef gzopen 1938 # endif 1939 # define gzopen gzopen64 1940 # ifdef gzseek 1941 # undef gzseek 1942 # endif 1943 # define gzseek gzseek64 1944 # ifdef gztell 1945 # undef gztell 1946 # endif 1947 # define gztell gztell64 1948 # ifdef gzoffset 1949 # undef gzoffset 1950 # endif 1951 # define gzoffset gzoffset64 1952 # ifdef adler32_combine 1953 # undef adler32_combine 1954 # endif 1955 # define adler32_combine adler32_combine64 1956 # ifdef crc32_combine 1957 # undef crc32_combine 1958 # endif 1959 # ifdef crc32_combine64 1960 # undef crc32_combine64 1961 # endif 1962 # ifdef crc32_combine_gen 1963 # undef crc32_combine_gen 1964 # endif 1965 # ifdef crc32_combine_op 1966 # undef crc32_combine_op 1967 # endif 1968 # endif 1969 # ifndef Z_LARGE64 1970 ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); 1971 ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); 1972 ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); 1973 ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); 1974 ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); 1975 ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); 1976 ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off_t)); 1977 # endif 1978 #else 1979 ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); 1980 ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); 1981 ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); 1982 ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); 1983 ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); 1984 ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); 1985 ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t)); 1986 #endif 1987 1988 #else /* Z_SOLO */ 1989 1990 ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); 1991 ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); 1992 ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t)); 1993 1994 #endif /* !Z_SOLO */ 1995 1996 /* undocumented functions */ 1997 ZEXTERN const char * ZEXPORT zError OF((int)); 1998 ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); 1999 ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); 2000 ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); 2001 #if !defined(__ANDROID__) || __ANDROID_API__ >= 28 2002 ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int)); 2003 #endif 2004 #if !defined(__ANDROID__) || __ANDROID_API__ >= 28 2005 ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp)); 2006 #endif 2007 ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); 2008 ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); 2009 #if defined(_WIN32) && !defined(Z_SOLO) 2010 ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, 2011 const char *mode)); 2012 #endif 2013 #if defined(STDC) || defined(Z_HAVE_STDARG_H) 2014 # ifndef Z_SOLO 2015 # if !defined(__ANDROID__) || __ANDROID_API__ >= 19 2016 ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, 2017 const char *format, 2018 va_list va)); 2019 # endif 2020 # endif 2021 #endif 2022 2023 #ifdef __cplusplus 2024 } 2025 #endif 2026 2027 #endif /* ZLIB_H */ 2028