2 WARNING: DO NOT UNCRUSTIFY
3 It will still compile after an uncrustify, but it will be *broken*
4 See https://github.com/TTimo/GtkRadiant/issues/33
8 Copyright (C) 1999-2007 id Software, Inc. and contributors.
9 For a list of contributors, see the accompanying CONTRIBUTORS file.
11 This file is part of GtkRadiant.
13 GtkRadiant is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 GtkRadiant is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GtkRadiant; if not, write to the Free Software
25 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
28 /*****************************************************************************
31 * desc: IO on .zip files using portions of zlib
34 *****************************************************************************/
41 // TTimo added for safe_malloc wrapping
44 /* unzip.h -- IO for uncompress .zip files using zlib
45 Version 0.15 beta, Mar 19th, 1998,
47 Copyright (C) 1998 Gilles Vollant
49 This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
50 WinZip, InfoZip tools and compatible.
51 Encryption and multi volume ZipFile (span) are not supported.
52 Old compressions used by old PKZip 1.x are not supported
54 THIS IS AN ALPHA VERSION. AT THIS STAGE OF DEVELOPPEMENT, SOMES API OR STRUCTURE
55 CAN CHANGE IN FUTURE VERSION !!
56 I WAIT FEEDBACK at mail info@winimage.com
57 Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
59 Condition of use and distribution are the same than zlib :
61 This software is provided 'as-is', without any express or implied
62 warranty. In no event will the authors be held liable for any damages
63 arising from the use of this software.
65 Permission is granted to anyone to use this software for any purpose,
66 including commercial applications, and to alter it and redistribute it
67 freely, subject to the following restrictions:
69 1. The origin of this software must not be misrepresented; you must not
70 claim that you wrote the original software. If you use this software
71 in a product, an acknowledgment in the product documentation would be
72 appreciated but is not required.
73 2. Altered source versions must be plainly marked as such, and must not be
74 misrepresented as being the original software.
75 3. This notice may not be removed or altered from any source distribution.
79 /* for more info about .ZIP format, see
80 ftp://ftp.cdrom.com/pub/infozip/doc/appnote-970311-iz.zip
81 PkWare has also a specification at :
82 ftp://ftp.pkware.com/probdesc.zip */
84 /* zlib.h -- interface of the 'zlib' general purpose compression library
85 version 1.1.3, July 9th, 1998
87 Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
89 This software is provided 'as-is', without any express or implied
90 warranty. In no event will the authors be held liable for any damages
91 arising from the use of this software.
93 Permission is granted to anyone to use this software for any purpose,
94 including commercial applications, and to alter it and redistribute it
95 freely, subject to the following restrictions:
97 1. The origin of this software must not be misrepresented; you must not
98 claim that you wrote the original software. If you use this software
99 in a product, an acknowledgment in the product documentation would be
100 appreciated but is not required.
101 2. Altered source versions must be plainly marked as such, and must not be
102 misrepresented as being the original software.
103 3. This notice may not be removed or altered from any source distribution.
105 Jean-loup Gailly Mark Adler
106 jloup@gzip.org madler@alumni.caltech.edu
109 The data format used by the zlib library is described by RFCs (Request for
110 Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
111 (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
114 /* zconf.h -- configuration of the zlib compression library
115 * Copyright (C) 1995-1998 Jean-loup Gailly.
116 * For conditions of distribution and use, see copyright notice in zlib.h
123 /* Maximum value for memLevel in deflateInit2 */
124 #ifndef MAX_MEM_LEVEL
126 # define MAX_MEM_LEVEL 8
128 # define MAX_MEM_LEVEL 9
132 /* Maximum value for windowBits in deflateInit2 and inflateInit2.
133 * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
134 * created by gzip. (Files created by minigzip can still be extracted by
138 # define MAX_WBITS 15 /* 32K LZ77 window */
141 /* The memory requirements for deflate are (in bytes):
142 (1 << (windowBits+2)) + (1 << (memLevel+9))
143 that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
144 plus a few kilobytes for small objects. For example, if you want to reduce
145 the default memory requirements from 256K to 128K, compile with
146 make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
147 Of course this will generally degrade compression (there's no free lunch).
149 The memory requirements for inflate are (in bytes) 1 << windowBits
150 that is, 32K for windowBits=15 (default value) plus a few kilobytes
154 /* Type declarations */
156 #ifndef OF /* function prototypes */
157 #define OF(args) args
160 typedef unsigned char Byte; /* 8 bits */
161 typedef unsigned int uInt; /* 16 bits or more */
162 typedef unsigned long uLong; /* 32 bits or more */
166 # define SEEK_SET 0 /* Seek from beginning of file. */
167 # define SEEK_CUR 1 /* Seek from current position. */
168 # define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
171 #endif /* _ZCONF_H */
173 #define ZLIB_VERSION "1.1.3"
176 The 'zlib' compression library provides in-memory compression and
177 decompression functions, including integrity checks of the uncompressed
178 data. This version of the library supports only one compression method
179 (deflation) but other algorithms will be added later and will have the same
182 Compression can be done in a single step if the buffers are large
183 enough (for example if an input file is mmap'ed), or can be done by
184 repeated calls of the compression function. In the latter case, the
185 application must provide more input and/or consume the output
186 (providing more output space) before each call.
188 The library also supports reading and writing files in gzip (.gz) format
189 with an interface similar to that of stdio.
191 The library does not install any signal handler. The decoder checks
192 the consistency of the compressed data, so the library should never
193 crash even in case of corrupted input.
197 The application must update next_in and avail_in when avail_in has
198 dropped to zero. It must update next_out and avail_out when avail_out
199 has dropped to zero. The application must initialize zalloc, zfree and
200 opaque before calling the init function. All other fields are set by the
201 compression library and must not be updated by the application.
203 The opaque value provided by the application will be passed as the first
204 parameter for calls of zalloc and zfree. This can be useful for custom
205 memory management. The compression library attaches no meaning to the
208 zalloc must return Z_NULL if there is not enough memory for the object.
209 If zlib is used in a multi-threaded application, zalloc and zfree must be
212 On 16-bit systems, the functions zalloc and zfree must be able to allocate
213 exactly 65536 bytes, but will not be required to allocate more than this
214 if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
215 pointers returned by zalloc for objects of exactly 65536 bytes *must*
216 have their offset normalized to zero. The default allocation function
217 provided by this library ensures this (see zutil.c). To reduce memory
218 requirements and avoid any allocation of 64K objects, at the expense of
219 compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
221 The fields total_in and total_out can be used for statistics or
222 progress reports. After compression, total_in holds the total size of
223 the uncompressed data and may be saved for use in the decompressor
224 (particularly if the decompressor wants to decompress everything in
231 #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
232 #define Z_SYNC_FLUSH 2
233 #define Z_FULL_FLUSH 3
235 /* Allowed flush values; see deflate() below for details */
238 #define Z_STREAM_END 1
239 #define Z_NEED_DICT 2
241 #define Z_STREAM_ERROR (-2)
242 #define Z_DATA_ERROR (-3)
243 #define Z_MEM_ERROR (-4)
244 #define Z_BUF_ERROR (-5)
245 #define Z_VERSION_ERROR (-6)
246 /* Return codes for the compression/decompression functions. Negative
247 * values are errors, positive values are used for special but normal events.
250 #define Z_NO_COMPRESSION 0
251 #define Z_BEST_SPEED 1
252 #define Z_BEST_COMPRESSION 9
253 #define Z_DEFAULT_COMPRESSION (-1)
254 /* compression levels */
257 #define Z_HUFFMAN_ONLY 2
258 #define Z_DEFAULT_STRATEGY 0
259 /* compression strategy; see deflateInit2() below for details */
264 /* Possible values of the data_type field */
267 /* The deflate compression method (the only one supported in this version) */
269 #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
271 #define zlib_version zlibVersion()
272 /* for compatibility with versions < 1.0.2 */
274 /* basic functions */
276 const char * zlibVersion OF((void));
277 /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
278 If the first character differs, the library code actually used is
279 not compatible with the zlib.h header file used by the application.
280 This check is automatically made by deflateInit and inflateInit.
284 int deflateInit OF((z_streamp strm, int level));
286 Initializes the internal stream state for compression. The fields
287 zalloc, zfree and opaque must be initialized before by the caller.
288 If zalloc and zfree are set to Z_NULL, deflateInit updates them to
289 use default allocation functions.
291 The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
292 1 gives best speed, 9 gives best compression, 0 gives no compression at
293 all (the input data is simply copied a block at a time).
294 Z_DEFAULT_COMPRESSION requests a default compromise between speed and
295 compression (currently equivalent to level 6).
297 deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
298 enough memory, Z_STREAM_ERROR if level is not a valid compression level,
299 Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
300 with the version assumed by the caller (ZLIB_VERSION).
301 msg is set to null if there is no error message. deflateInit does not
302 perform any compression: this will be done by deflate().
306 int deflate OF((z_streamp strm, int flush));
308 deflate compresses as much data as possible, and stops when the input
309 buffer becomes empty or the output buffer becomes full. It may introduce some
310 output latency (reading input without producing any output) except when
313 The detailed semantics are as follows. deflate performs one or both of the
316 - Compress more input starting at next_in and update next_in and avail_in
317 accordingly. If not all input can be processed (because there is not
318 enough room in the output buffer), next_in and avail_in are updated and
319 processing will resume at this point for the next call of deflate().
321 - Provide more output starting at next_out and update next_out and avail_out
322 accordingly. This action is forced if the parameter flush is non zero.
323 Forcing flush frequently degrades the compression ratio, so this parameter
324 should be set only when necessary (in interactive applications).
325 Some output may be provided even if flush is not set.
327 Before the call of deflate(), the application should ensure that at least
328 one of the actions is possible, by providing more input and/or consuming
329 more output, and updating avail_in or avail_out accordingly; avail_out
330 should never be zero before the call. The application can consume the
331 compressed output when it wants, for example when the output buffer is full
332 (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
333 and with zero avail_out, it must be called again after making room in the
334 output buffer because there might be more output pending.
336 If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
337 flushed to the output buffer and the output is aligned on a byte boundary, so
338 that the decompressor can get all input data available so far. (In particular
339 avail_in is zero after the call if enough output space has been provided
340 before the call.) Flushing may degrade compression for some compression
341 algorithms and so it should be used only when necessary.
343 If flush is set to Z_FULL_FLUSH, all output is flushed as with
344 Z_SYNC_FLUSH, and the compression state is reset so that decompression can
345 restart from this point if previous compressed data has been damaged or if
346 random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
349 If deflate returns with avail_out == 0, this function must be called again
350 with the same value of the flush parameter and more output space (updated
351 avail_out), until the flush is complete (deflate returns with non-zero
354 If the parameter flush is set to Z_FINISH, pending input is processed,
355 pending output is flushed and deflate returns with Z_STREAM_END if there
356 was enough output space; if deflate returns with Z_OK, this function must be
357 called again with Z_FINISH and more output space (updated avail_out) but no
358 more input data, until it returns with Z_STREAM_END or an error. After
359 deflate has returned Z_STREAM_END, the only possible operations on the
360 stream are deflateReset or deflateEnd.
362 Z_FINISH can be used immediately after deflateInit if all the compression
363 is to be done in a single step. In this case, avail_out must be at least
364 0.1% larger than avail_in plus 12 bytes. If deflate does not return
365 Z_STREAM_END, then it must be called again as described above.
367 deflate() sets strm->adler to the adler32 checksum of all input read
368 so (that is, total_in bytes).
370 deflate() may update data_type if it can make a good guess about
371 the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
372 binary. This field is only for information purposes and does not affect
373 the compression algorithm in any manner.
375 deflate() returns Z_OK if some progress has been made (more input
376 processed or more output produced), Z_STREAM_END if all input has been
377 consumed and all output has been produced (only when flush is set to
378 Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
379 if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
380 (for example avail_in or avail_out was zero).
384 int deflateEnd OF((z_streamp strm));
386 All dynamically allocated data structures for this stream are freed.
387 This function discards any unprocessed input and does not flush any
390 deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
391 stream state was inconsistent, Z_DATA_ERROR if the stream was freed
392 prematurely (some input or output was discarded). In the error case,
393 msg may be set but then points to a static string (which must not be
399 int inflateInit OF((z_streamp strm));
401 Initializes the internal stream state for decompression. The fields
402 next_in, avail_in, zalloc, zfree and opaque must be initialized before by
403 the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
404 value depends on the compression method), inflateInit determines the
405 compression method from the zlib header and allocates all data structures
406 accordingly; otherwise the allocation will be deferred to the first call of
407 inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
408 use default allocation functions.
410 inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
411 memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
412 version assumed by the caller. msg is set to null if there is no error
413 message. inflateInit does not perform any decompression apart from reading
414 the zlib header if present: this will be done by inflate(). (So next_in and
415 avail_in may be modified, but next_out and avail_out are unchanged.)
419 int inflate OF((z_streamp strm, int flush));
421 inflate decompresses as much data as possible, and stops when the input
422 buffer becomes empty or the output buffer becomes full. It may some
423 introduce some output latency (reading input without producing any output)
424 except when forced to flush.
426 The detailed semantics are as follows. inflate performs one or both of the
429 - Decompress more input starting at next_in and update next_in and avail_in
430 accordingly. If not all input can be processed (because there is not
431 enough room in the output buffer), next_in is updated and processing
432 will resume at this point for the next call of inflate().
434 - Provide more output starting at next_out and update next_out and avail_out
435 accordingly. inflate() provides as much output as possible, until there
436 is no more input data or no more space in the output buffer (see below
437 about the flush parameter).
439 Before the call of inflate(), the application should ensure that at least
440 one of the actions is possible, by providing more input and/or consuming
441 more output, and updating the next_* and avail_* values accordingly.
442 The application can consume the uncompressed output when it wants, for
443 example when the output buffer is full (avail_out == 0), or after each
444 call of inflate(). If inflate returns Z_OK and with zero avail_out, it
445 must be called again after making room in the output buffer because there
446 might be more output pending.
448 If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
449 output as possible to the output buffer. The flushing behavior of inflate is
450 not specified for values of the flush parameter other than Z_SYNC_FLUSH
451 and Z_FINISH, but the current implementation actually flushes as much output
454 inflate() should normally be called until it returns Z_STREAM_END or an
455 error. However if all decompression is to be performed in a single step
456 (a single call of inflate), the parameter flush should be set to
457 Z_FINISH. In this case all pending input is processed and all pending
458 output is flushed; avail_out must be large enough to hold all the
459 uncompressed data. (The size of the uncompressed data may have been saved
460 by the compressor for this purpose.) The next operation on this stream must
461 be inflateEnd to deallocate the decompression state. The use of Z_FINISH
462 is never required, but can be used to inform inflate that a faster routine
463 may be used for the single inflate() call.
465 If a preset dictionary is needed at this point (see inflateSetDictionary
466 below), inflate sets strm-adler to the adler32 checksum of the
467 dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise
468 it sets strm->adler to the adler32 checksum of all output produced
469 so (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
470 an error code as described below. At the end of the stream, inflate()
471 checks that its computed adler32 checksum is equal to that saved by the
472 compressor and returns Z_STREAM_END only if the checksum is correct.
474 inflate() returns Z_OK if some progress has been made (more input processed
475 or more output produced), Z_STREAM_END if the end of the compressed data has
476 been reached and all uncompressed output has been produced, Z_NEED_DICT if a
477 preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
478 corrupted (input stream not conforming to the zlib format or incorrect
479 adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
480 (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
481 enough memory, Z_BUF_ERROR if no progress is possible or if there was not
482 enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
483 case, the application may then call inflateSync to look for a good
488 int inflateEnd OF((z_streamp strm));
490 All dynamically allocated data structures for this stream are freed.
491 This function discards any unprocessed input and does not flush any
494 inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
495 was inconsistent. In the error case, msg may be set but then points to a
496 static string (which must not be deallocated).
499 /* Advanced functions */
502 The following functions are needed only in some special applications.
506 int deflateInit2 OF((z_streamp strm,
513 This is another version of deflateInit with more compression options. The
514 fields next_in, zalloc, zfree and opaque must be initialized before by
517 The method parameter is the compression method. It must be Z_DEFLATED in
518 this version of the library.
520 The windowBits parameter is the base two logarithm of the window size
521 (the size of the history buffer). It should be in the range 8..15 for this
522 version of the library. Larger values of this parameter result in better
523 compression at the expense of memory usage. The default value is 15 if
524 deflateInit is used instead.
526 The memLevel parameter specifies how much memory should be allocated
527 for the internal compression state. memLevel=1 uses minimum memory but
528 is slow and reduces compression ratio; memLevel=9 uses maximum memory
529 for optimal speed. The default value is 8. See zconf.h for total memory
530 usage as a function of windowBits and memLevel.
532 The strategy parameter is used to tune the compression algorithm. Use the
533 value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
534 filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
535 string match). Filtered data consists mostly of small values with a
536 somewhat random distribution. In this case, the compression algorithm is
537 tuned to compress them better. The effect of Z_FILTERED is to force more
538 Huffman coding and less string matching; it is somewhat intermediate
539 between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
540 the compression ratio but not the correctness of the compressed output even
541 if it is not set appropriately.
543 deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
544 memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
545 method). msg is set to null if there is no error message. deflateInit2 does
546 not perform any compression: this will be done by deflate().
549 int deflateSetDictionary OF((z_streamp strm,
550 const Byte *dictionary,
553 Initializes the compression dictionary from the given byte sequence
554 without producing any compressed output. This function must be called
555 immediately after deflateInit, deflateInit2 or deflateReset, before any
556 call of deflate. The compressor and decompressor must use exactly the same
557 dictionary (see inflateSetDictionary).
559 The dictionary should consist of strings (byte sequences) that are likely
560 to be encountered later in the data to be compressed, with the most commonly
561 used strings preferably put towards the end of the dictionary. Using a
562 dictionary is most useful when the data to be compressed is short and can be
563 predicted with good accuracy; the data can then be compressed better than
564 with the default empty dictionary.
566 Depending on the size of the compression data structures selected by
567 deflateInit or deflateInit2, a part of the dictionary may in effect be
568 discarded, for example if the dictionary is larger than the window size in
569 deflate or deflate2. Thus the strings most likely to be useful should be
570 put at the end of the dictionary, not at the front.
572 Upon return of this function, strm->adler is set to the Adler32 value
573 of the dictionary; the decompressor may later use this value to determine
574 which dictionary has been used by the compressor. (The Adler32 value
575 applies to the whole dictionary even if only a subset of the dictionary is
576 actually used by the compressor.)
578 deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
579 parameter is invalid (such as NULL dictionary) or the stream state is
580 inconsistent (for example if deflate has already been called for this stream
581 or if the compression method is bsort). deflateSetDictionary does not
582 perform any compression: this will be done by deflate().
585 int deflateCopy OF((z_streamp dest,
588 Sets the destination stream as a complete copy of the source stream.
590 This function can be useful when several compression strategies will be
591 tried, for example when there are several ways of pre-processing the input
592 data with a filter. The streams that will be discarded should then be freed
593 by calling deflateEnd. Note that deflateCopy duplicates the internal
594 compression state which can be quite large, so this strategy is slow and
595 can consume lots of memory.
597 deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
598 enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
599 (such as zalloc being NULL). msg is left unchanged in both source and
603 int deflateReset OF((z_streamp strm));
605 This function is equivalent to deflateEnd followed by deflateInit,
606 but does not free and reallocate all the internal compression state.
607 The stream will keep the same compression level and any other attributes
608 that may have been set by deflateInit2.
610 deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
611 stream state was inconsistent (such as zalloc or state being NULL).
614 int deflateParams OF((z_streamp strm,
618 Dynamically update the compression level and compression strategy. The
619 interpretation of level and strategy is as in deflateInit2. This can be
620 used to switch between compression and straight copy of the input data, or
621 to switch to a different kind of input data requiring a different
622 strategy. If the compression level is changed, the input available so far
623 is compressed with the old level (and may be flushed); the new level will
624 take effect only at the next call of deflate().
626 Before the call of deflateParams, the stream state must be set as for
627 a call of deflate(), since the currently available input may have to
628 be compressed and flushed. In particular, strm->avail_out must be non-zero.
630 deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
631 stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
632 if strm->avail_out was zero.
636 int inflateInit2 OF((z_streamp strm,
639 This is another version of inflateInit with an extra parameter. The
640 fields next_in, avail_in, zalloc, zfree and opaque must be initialized
641 before by the caller.
643 The windowBits parameter is the base two logarithm of the maximum window
644 size (the size of the history buffer). It should be in the range 8..15 for
645 this version of the library. The default value is 15 if inflateInit is used
646 instead. If a compressed stream with a larger window size is given as
647 input, inflate() will return with the error code Z_DATA_ERROR instead of
648 trying to allocate a larger window.
650 inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
651 memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
652 memLevel). msg is set to null if there is no error message. inflateInit2
653 does not perform any decompression apart from reading the zlib header if
654 present: this will be done by inflate(). (So next_in and avail_in may be
655 modified, but next_out and avail_out are unchanged.)
658 int inflateSetDictionary OF((z_streamp strm,
659 const Byte *dictionary,
662 Initializes the decompression dictionary from the given uncompressed byte
663 sequence. This function must be called immediately after a call of inflate
664 if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
665 can be determined from the Adler32 value returned by this call of
666 inflate. The compressor and decompressor must use exactly the same
667 dictionary (see deflateSetDictionary).
669 inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
670 parameter is invalid (such as NULL dictionary) or the stream state is
671 inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
672 expected one (incorrect Adler32 value). inflateSetDictionary does not
673 perform any decompression: this will be done by subsequent calls of
677 int inflateSync OF((z_streamp strm));
679 Skips invalid compressed data until a full flush point (see above the
680 description of deflate with Z_FULL_FLUSH) can be found, or until all
681 available input is skipped. No output is provided.
683 inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
684 if no more input was provided, Z_DATA_ERROR if no flush point has been found,
685 or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
686 case, the application may save the current current value of total_in which
687 indicates where valid compressed data was found. In the error case, the
688 application may repeatedly call inflateSync, providing more input each time,
689 until success or end of the input data.
692 int inflateReset OF((z_streamp strm));
694 This function is equivalent to inflateEnd followed by inflateInit,
695 but does not free and reallocate all the internal decompression state.
696 The stream will keep attributes that may have been set by inflateInit2.
698 inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
699 stream state was inconsistent (such as zalloc or state being NULL).
703 /* utility functions */
706 The following utility functions are implemented on top of the
707 basic stream-oriented functions. To simplify the interface, some
708 default options are assumed (compression level and memory usage,
709 standard memory allocation functions). The source code of these
710 utility functions can easily be modified if you need special options.
713 int compress OF((Byte *dest, uLong *destLen,
714 const Byte *source, uLong sourceLen));
716 Compresses the source buffer into the destination buffer. sourceLen is
717 the byte length of the source buffer. Upon entry, destLen is the total
718 size of the destination buffer, which must be at least 0.1% larger than
719 sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
721 This function can be used to compress a whole file at once if the
722 input file is mmap'ed.
723 compress returns Z_OK if success, Z_MEM_ERROR if there was not
724 enough memory, Z_BUF_ERROR if there was not enough room in the output
728 int compress2 OF((Byte *dest, uLong *destLen,
729 const Byte *source, uLong sourceLen,
732 Compresses the source buffer into the destination buffer. The level
733 parameter has the same meaning as in deflateInit. sourceLen is the byte
734 length of the source buffer. Upon entry, destLen is the total size of the
735 destination buffer, which must be at least 0.1% larger than sourceLen plus
736 12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
738 compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
739 memory, Z_BUF_ERROR if there was not enough room in the output buffer,
740 Z_STREAM_ERROR if the level parameter is invalid.
743 int uncompress OF((Byte *dest, uLong *destLen,
744 const Byte *source, uLong sourceLen));
746 Decompresses the source buffer into the destination buffer. sourceLen is
747 the byte length of the source buffer. Upon entry, destLen is the total
748 size of the destination buffer, which must be large enough to hold the
749 entire uncompressed data. (The size of the uncompressed data must have
750 been saved previously by the compressor and transmitted to the decompressor
751 by some mechanism outside the scope of this compression library.)
752 Upon exit, destLen is the actual size of the compressed buffer.
753 This function can be used to decompress a whole file at once if the
754 input file is mmap'ed.
756 uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
757 enough memory, Z_BUF_ERROR if there was not enough room in the output
758 buffer, or Z_DATA_ERROR if the input data was corrupted.
762 typedef voidp gzFile;
764 gzFile gzopen OF((const char *path, const char *mode));
766 Opens a gzip (.gz) file for reading or writing. The mode parameter
767 is as in fopen ("rb" or "wb") but can also include a compression level
768 ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
769 Huffman only compression as in "wb1h". (See the description
770 of deflateInit2 for more information about the strategy parameter.)
772 gzopen can be used to read a file which is not in gzip format; in this
773 case gzread will directly read from the file without decompression.
775 gzopen returns NULL if the file could not be opened or if there was
776 insufficient memory to allocate the (de)compression state; errno
777 can be checked to distinguish the two cases (if errno is zero, the
778 zlib error is Z_MEM_ERROR). */
780 gzFile gzdopen OF((int fd, const char *mode));
782 gzdopen() associates a gzFile with the file descriptor fd. File
783 descriptors are obtained from calls like open, dup, creat, pipe or
784 fileno (in the file has been previously opened with fopen).
785 The mode parameter is as in gzopen.
786 The next call of gzclose on the returned gzFile will also close the
787 file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
788 descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
789 gzdopen returns NULL if there was insufficient memory to allocate
790 the (de)compression state.
793 int gzsetparams OF((gzFile file, int level, int strategy));
795 Dynamically update the compression level or strategy. See the description
796 of deflateInit2 for the meaning of these parameters.
797 gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
801 int gzread OF((gzFile file, voidp buf, unsigned len));
803 Reads the given number of uncompressed bytes from the compressed file.
804 If the input file was not in gzip format, gzread copies the given number
805 of bytes into the buffer.
806 gzread returns the number of uncompressed bytes actually read (0 for
807 end of file, -1 for error). */
809 int gzwrite OF((gzFile file,
810 const voidp buf, unsigned len));
812 Writes the given number of uncompressed bytes into the compressed file.
813 gzwrite returns the number of uncompressed bytes actually written
814 (0 in case of error).
817 int gzprintf OF((gzFile file, const char *format, ...));
819 Converts, formats, and writes the args to the compressed file under
820 control of the format string, as in fprintf. gzprintf returns the number of
821 uncompressed bytes actually written (0 in case of error).
824 int gzputs OF((gzFile file, const char *s));
826 Writes the given null-terminated string to the compressed file, excluding
827 the terminating null character.
828 gzputs returns the number of characters written, or -1 in case of error.
831 char * gzgets OF((gzFile file, char *buf, int len));
833 Reads bytes from the compressed file until len-1 characters are read, or
834 a newline character is read and transferred to buf, or an end-of-file
835 condition is encountered. The string is then terminated with a null
837 gzgets returns buf, or Z_NULL in case of error.
840 int gzputc OF((gzFile file, int c));
842 Writes c, converted to an unsigned char, into the compressed file.
843 gzputc returns the value that was written, or -1 in case of error.
846 int gzgetc OF((gzFile file));
848 Reads one byte from the compressed file. gzgetc returns this byte
849 or -1 in case of end of file or error.
852 int gzflush OF((gzFile file, int flush));
854 Flushes all pending output into the compressed file. The parameter
855 flush is as in the deflate() function. The return value is the zlib
856 error number (see function gzerror below). gzflush returns Z_OK if
857 the flush parameter is Z_FINISH and all output could be flushed.
858 gzflush should be called only when strictly necessary because it can
862 long gzseek OF((gzFile file,
863 long offset, int whence));
865 Sets the starting position for the next gzread or gzwrite on the
866 given compressed file. The offset represents a number of bytes in the
867 uncompressed data stream. The whence parameter is defined as in lseek(2);
868 the value SEEK_END is not supported.
869 If the file is opened for reading, this function is emulated but can be
870 extremely slow. If the file is opened for writing, only forward seeks are
871 supported; gzseek then compresses a sequence of zeroes up to the new
874 gzseek returns the resulting offset location as measured in bytes from
875 the beginning of the uncompressed stream, or -1 in case of error, in
876 particular if the file is opened for writing and the new starting position
877 would be before the current position.
880 int gzrewind OF((gzFile file));
882 Rewinds the given file. This function is supported only for reading.
884 gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
887 long gztell OF((gzFile file));
889 Returns the starting position for the next gzread or gzwrite on the
890 given compressed file. This position represents a number of bytes in the
891 uncompressed data stream.
893 gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
896 int gzeof OF((gzFile file));
898 Returns 1 when EOF has previously been detected reading the given
899 input stream, otherwise zero.
902 int gzclose OF((gzFile file));
904 Flushes all pending output if necessary, closes the compressed file
905 and deallocates all the (de)compression state. The return value is the zlib
906 error number (see function gzerror below).
909 const char * gzerror OF((gzFile file, int *errnum));
911 Returns the error message for the last error which occurred on the
912 given compressed file. errnum is set to zlib error number. If an
913 error occurred in the file system and not in the compression library,
914 errnum is set to Z_ERRNO and the application may consult errno
915 to get the exact error code.
918 /* checksum functions */
921 These functions are not related to compression but are exported
922 anyway because they might be useful in applications using the
926 uLong adler32 OF((uLong adler, const Byte *buf, uInt len));
929 Update a running Adler-32 checksum with the bytes buf[0..len-1] and
930 return the updated checksum. If buf is NULL, this function returns
931 the required initial value for the checksum.
932 An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
933 much faster. Usage example:
935 uLong adler = adler32(0L, Z_NULL, 0);
937 while (read_buffer(buffer, length) != EOF) {
938 adler = adler32(adler, buffer, length);
940 if (adler != original_adler) error();
943 uLong crc32 OF((uLong crc, const Byte *buf, uInt len));
945 Update a running crc with the bytes buf[0..len-1] and return the updated
946 crc. If buf is NULL, this function returns the required initial value
947 for the crc. Pre- and post-conditioning (one's complement) is performed
948 within this function so it shouldn't be done by the application.
951 uLong crc = crc32(0L, Z_NULL, 0);
953 while (read_buffer(buffer, length) != EOF) {
954 crc = crc32(crc, buffer, length);
956 if (crc != original_crc) error();
959 // private stuff to not include cmdlib.h
961 ============================================================================
965 ============================================================================
969 #define __BIG_ENDIAN__
972 #ifdef __BIG_ENDIAN__
974 short __LittleShort (short l)
984 short __BigShort (short l)
990 int __LittleLong (int l)
999 return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
1002 int __BigLong (int l)
1008 float __LittleFloat (float l)
1010 union {byte b[4]; float f;} in, out;
1021 float __BigFloat (float l)
1030 short __BigShort (short l)
1037 return (b1<<8) + b2;
1040 short __LittleShort (short l)
1046 int __BigLong (int l)
1055 return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
1058 int __LittleLong (int l)
1063 float __BigFloat (float l)
1065 union {byte b[4]; float f;} in, out;
1076 float __LittleFloat (float l)
1088 /* various hacks, don't look :) */
1090 /* deflateInit and inflateInit are macros to allow checking the zlib version
1091 * and the compiler's view of z_stream:
1093 int deflateInit_ OF((z_streamp strm, int level,
1094 const char *version, int stream_size));
1095 int inflateInit_ OF((z_streamp strm,
1096 const char *version, int stream_size));
1097 int deflateInit2_ OF((z_streamp strm, int level, int method,
1098 int windowBits, int memLevel,
1099 int strategy, const char *version,
1101 int inflateInit2_ OF((z_streamp strm, int windowBits,
1102 const char *version, int stream_size));
1103 #define deflateInit(strm, level) \
1104 deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
1105 #define inflateInit(strm) \
1106 inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))
1107 #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
1108 deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
1109 (strategy), ZLIB_VERSION, sizeof(z_stream))
1110 #define inflateInit2(strm, windowBits) \
1111 inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
1114 const char * zError OF((int err));
1115 int inflateSyncPoint OF((z_streamp z));
1116 const uLong * get_crc_table OF((void));
1118 typedef unsigned char uch;
1119 typedef unsigned short ush;
1120 typedef unsigned long ulg;
1122 extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
1123 /* (size given to avoid silly warnings with Visual C++) */
1125 #define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
1127 #define ERR_RETURN(strm,err) \
1128 return (strm->msg = (char*)ERR_MSG(err), (err))
1129 /* To be used only when the state is known to be valid */
1131 /* common constants */
1134 # define DEF_WBITS MAX_WBITS
1136 /* default windowBits for decompression. MAX_WBITS is for compression only */
1138 #if MAX_MEM_LEVEL >= 8
1139 # define DEF_MEM_LEVEL 8
1141 # define DEF_MEM_LEVEL MAX_MEM_LEVEL
1143 /* default memLevel */
1145 #define STORED_BLOCK 0
1146 #define STATIC_TREES 1
1148 /* The three kinds of block type */
1151 #define MAX_MATCH 258
1152 /* The minimum and maximum match lengths */
1154 #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
1156 /* target dependencies */
1158 /* Common defaults */
1161 # define OS_CODE 0x03 /* assume Unix */
1165 # define F_OPEN(name, mode) fopen((name), (mode))
1170 #ifdef HAVE_STRERROR
1171 extern char *strerror OF((int));
1172 # define zstrerror(errnum) strerror(errnum)
1174 # define zstrerror(errnum) ""
1177 #define zmemcpy memcpy
1178 #define zmemcmp memcmp
1179 #define zmemzero(dest, len) memset(dest, 0, len)
1181 /* Diagnostic functions */
1184 # define Assert(cond,msg) assert(cond);
1185 //{if(!(cond)) Sys_Error(msg);}
1186 # define Trace(x) {if (z_verbose>=0) Sys_Error x ;}
1187 # define Tracev(x) {if (z_verbose>0) Sys_Error x ;}
1188 # define Tracevv(x) {if (z_verbose>1) Sys_Error x ;}
1189 # define Tracec(c,x) {if (z_verbose>0 && (c)) Sys_Error x ;}
1190 # define Tracecv(c,x) {if (z_verbose>1 && (c)) Sys_Error x ;}
1192 # define Assert(cond,msg)
1196 # define Tracec(c,x)
1197 # define Tracecv(c,x)
1201 typedef uLong (*check_func) OF((uLong check, const Byte *buf, uInt len));
1202 voidp zcalloc OF((voidp opaque, unsigned items, unsigned size));
1203 void zcfree OF((voidp opaque, voidp ptr));
1205 #define ZALLOC(strm, items, size) \
1206 (*((strm)->zalloc))((strm)->opaque, (items), (size))
1207 #define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidp)(addr))
1208 #define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
1211 #if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
1212 !defined(CASESENSITIVITYDEFAULT_NO)
1213 #define CASESENSITIVITYDEFAULT_NO
1218 #define UNZ_BUFSIZE (65536)
1221 #ifndef UNZ_MAXFILENAMEINZIP
1222 #define UNZ_MAXFILENAMEINZIP (256)
1226 # define ALLOC(size) (safe_malloc(size))
1229 # define TRYFREE(p) {if (p) free(p);}
1232 #define SIZECENTRALDIRITEM (0x2e)
1233 #define SIZEZIPLOCALHEADER (0x1e)
1237 /* ===========================================================================
1238 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
1240 IN assertion: the stream s has been sucessfully opened for reading.
1244 static int unzlocal_getByte(FILE *fin,int *pi)
1247 int err = fread(&c, 1, 1, fin);
1263 /* ===========================================================================
1264 Reads a long in LSB order from the given gz_stream. Sets
1266 static int unzlocal_getShort (FILE* fin, uLong *pX)
1270 if ( fread( &v, sizeof( v ), 1, fin ) != 1 ) {
1274 *pX = __LittleShort( v);
1282 err = unzlocal_getByte(fin,&i);
1286 err = unzlocal_getByte(fin,&i);
1297 static int unzlocal_getLong (FILE *fin, uLong *pX)
1301 if ( fread( &v, sizeof( v ), 1, fin ) != 1 ) {
1305 *pX = __LittleLong( v);
1313 err = unzlocal_getByte(fin,&i);
1317 err = unzlocal_getByte(fin,&i);
1321 err = unzlocal_getByte(fin,&i);
1322 x += ((uLong)i)<<16;
1325 err = unzlocal_getByte(fin,&i);
1326 x += ((uLong)i)<<24;
1337 /* My own strcmpi / strcasecmp */
1338 static int strcmpcasenosensitive_internal (const char* fileName1,const char* fileName2)
1342 char c1=*(fileName1++);
1343 char c2=*(fileName2++);
1344 if ((c1>='a') && (c1<='z'))
1346 if ((c2>='a') && (c2<='z'))
1349 return ((c2=='\0') ? 0 : -1);
1360 #ifdef CASESENSITIVITYDEFAULT_NO
1361 #define CASESENSITIVITYDEFAULTVALUE 2
1363 #define CASESENSITIVITYDEFAULTVALUE 1
1366 #ifndef STRCMPCASENOSENTIVEFUNCTION
1367 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
1371 Compare two filename (fileName1,fileName2).
1372 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
1373 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
1375 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
1376 (like 1 on Unix, 2 on Windows)
1379 extern int unzStringFileNameCompare (const char* fileName1,const char* fileName2,int iCaseSensitivity)
1381 if (iCaseSensitivity==0)
1382 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
1384 if (iCaseSensitivity==1)
1385 return strcmp(fileName1,fileName2);
1387 return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
1390 #define BUFREADCOMMENT (0x400)
1393 Locate the Central directory of a zipfile (at the end, just before
1396 static uLong unzlocal_SearchCentralDir(FILE *fin)
1401 uLong uMaxBack=0xffff; /* maximum size of global comment */
1404 if (fseek(fin,0,SEEK_END) != 0)
1408 uSizeFile = ftell( fin );
1410 if (uMaxBack>uSizeFile)
1411 uMaxBack = uSizeFile;
1413 buf = (unsigned char*)safe_malloc(BUFREADCOMMENT+4);
1418 while (uBackRead<uMaxBack)
1420 uLong uReadSize,uReadPos ;
1422 if (uBackRead+BUFREADCOMMENT>uMaxBack)
1423 uBackRead = uMaxBack;
1425 uBackRead+=BUFREADCOMMENT;
1426 uReadPos = uSizeFile-uBackRead ;
1428 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
1429 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
1430 if (fseek(fin,uReadPos,SEEK_SET)!=0)
1433 if (fread(buf,(uInt)uReadSize,1,fin)!=1)
1436 for (i=(int)uReadSize-3; (i--)>0;)
1437 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
1438 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
1440 uPosFound = uReadPos+i;
1451 extern unzFile unzReOpen (const char* path, unzFile file)
1456 fin=fopen(path,"rb");
1460 s=(unz_s*)safe_malloc(sizeof(unz_s));
1461 memcpy(s, (unz_s*)file, sizeof(unz_s));
1468 Open a Zip file. path contain the full pathname (by example,
1469 on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
1471 If the zipfile cannot be opened (file don't exist or in not valid), the
1472 return value is NULL.
1473 Else, the return value is a unzFile Handle, usable with other function
1474 of this unzip package.
1476 extern unzFile unzOpen (const char* path)
1480 uLong central_pos,uL;
1483 uLong number_disk; /* number of the current dist, used for
1484 spaning ZIP, unsupported, always 0*/
1485 uLong number_disk_with_CD; /* number the the disk with central dir, used
1486 for spaning ZIP, unsupported, always 0*/
1487 uLong number_entry_CD; /* total number of entries in
1489 (same than number_entry on nospan) */
1493 fin=fopen(path,"rb");
1497 central_pos = unzlocal_SearchCentralDir(fin);
1501 if (fseek(fin,central_pos,SEEK_SET)!=0)
1504 /* the signature, already checked */
1505 if (unzlocal_getLong(fin,&uL)!=UNZ_OK)
1508 /* number of this disk */
1509 if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK)
1512 /* number of the disk with the start of the central directory */
1513 if (unzlocal_getShort(fin,&number_disk_with_CD)!=UNZ_OK)
1516 /* total number of entries in the central dir on this disk */
1517 if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK)
1520 /* total number of entries in the central dir */
1521 if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK)
1524 if ((number_entry_CD!=us.gi.number_entry) ||
1525 (number_disk_with_CD!=0) ||
1529 /* size of the central directory */
1530 if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK)
1533 /* offset of start of central directory with respect to the
1534 starting disk number */
1535 if (unzlocal_getLong(fin,&us.offset_central_dir)!=UNZ_OK)
1538 /* zipfile comment length */
1539 if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK)
1542 if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
1553 us.byte_before_the_zipfile = central_pos -
1554 (us.offset_central_dir+us.size_central_dir);
1555 us.central_pos = central_pos;
1556 us.pfile_in_zip_read = NULL;
1559 s=(unz_s*)safe_malloc(sizeof(unz_s));
1561 // unzGoToFirstFile((unzFile)s);
1567 Close a ZipFile opened with unzipOpen.
1568 If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
1569 these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
1570 return UNZ_OK if there is no problem. */
1571 extern int unzClose (unzFile file)
1575 return UNZ_PARAMERROR;
1578 if (s->pfile_in_zip_read!=NULL)
1579 unzCloseCurrentFile(file);
1588 Write info about the ZipFile in the *pglobal_info structure.
1589 No preparation of the structure is needed
1590 return UNZ_OK if there is no problem. */
1591 extern int unzGetGlobalInfo (unzFile file,unz_global_info *pglobal_info)
1595 return UNZ_PARAMERROR;
1597 *pglobal_info=s->gi;
1603 Translate date/time from Dos format to tm_unz (readable more easilty)
1605 static void unzlocal_DosDateToTmuDate (uLong ulDosDate, tm_unz* ptm)
1608 uDate = (uLong)(ulDosDate>>16);
1609 ptm->tm_mday = (uInt)(uDate&0x1f) ;
1610 ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;
1611 ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
1613 ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
1614 ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
1615 ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
1619 Get Info about the current file in the zipfile, with internal only info
1621 static int unzlocal_GetCurrentFileInfoInternal (unzFile file,
1622 unz_file_info *pfile_info,
1623 unz_file_info_internal
1624 *pfile_info_internal,
1626 uLong fileNameBufferSize,
1628 uLong extraFieldBufferSize,
1630 uLong commentBufferSize)
1633 unz_file_info file_info;
1634 unz_file_info_internal file_info_internal;
1640 return UNZ_PARAMERROR;
1642 if (fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0)
1646 /* we check the magic */
1648 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
1650 else if (uMagic!=0x02014b50)
1654 if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK)
1657 if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK)
1660 if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK)
1663 if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK)
1666 if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK)
1669 unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
1671 if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK)
1674 if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK)
1677 if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK)
1680 if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK)
1683 if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK)
1686 if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK)
1689 if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK)
1692 if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK)
1695 if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK)
1698 if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK)
1701 lSeek+=file_info.size_filename;
1702 if ((err==UNZ_OK) && (szFileName!=NULL))
1705 if (file_info.size_filename<fileNameBufferSize)
1707 *(szFileName+file_info.size_filename)='\0';
1708 uSizeRead = file_info.size_filename;
1711 uSizeRead = fileNameBufferSize;
1713 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
1714 if (fread(szFileName,(uInt)uSizeRead,1,s->file)!=1)
1720 if ((err==UNZ_OK) && (extraField!=NULL))
1723 if (file_info.size_file_extra<extraFieldBufferSize)
1724 uSizeRead = file_info.size_file_extra;
1726 uSizeRead = extraFieldBufferSize;
1729 if (fseek(s->file,lSeek,SEEK_CUR)==0)
1734 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
1735 if (fread(extraField,(uInt)uSizeRead,1,s->file)!=1)
1737 lSeek += file_info.size_file_extra - uSizeRead;
1740 lSeek+=file_info.size_file_extra;
1743 if ((err==UNZ_OK) && (szComment!=NULL))
1746 if (file_info.size_file_comment<commentBufferSize)
1748 *(szComment+file_info.size_file_comment)='\0';
1749 uSizeRead = file_info.size_file_comment;
1752 uSizeRead = commentBufferSize;
1755 if (fseek(s->file,lSeek,SEEK_CUR)==0)
1760 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
1761 if (fread(szComment,(uInt)uSizeRead,1,s->file)!=1)
1763 lSeek+=file_info.size_file_comment - uSizeRead;
1766 lSeek+=file_info.size_file_comment;
1768 if ((err==UNZ_OK) && (pfile_info!=NULL))
1769 *pfile_info=file_info;
1771 if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
1772 *pfile_info_internal=file_info_internal;
1780 Write info about the ZipFile in the *pglobal_info structure.
1781 No preparation of the structure is needed
1782 return UNZ_OK if there is no problem.
1784 extern int unzGetCurrentFileInfo ( unzFile file, unz_file_info *pfile_info,
1785 char *szFileName, uLong fileNameBufferSize,
1786 void *extraField, uLong extraFieldBufferSize,
1787 char *szComment, uLong commentBufferSize)
1789 return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
1790 szFileName,fileNameBufferSize,
1791 extraField,extraFieldBufferSize,
1792 szComment,commentBufferSize);
1796 Set the current file of the zipfile to the first file.
1797 return UNZ_OK if there is no problem
1799 extern int unzGoToFirstFile (unzFile file)
1804 return UNZ_PARAMERROR;
1806 s->pos_in_central_dir=s->offset_central_dir;
1808 err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1809 &s->cur_file_info_internal,
1810 NULL,0,NULL,0,NULL,0);
1811 s->current_file_ok = (err == UNZ_OK);
1817 Set the current file of the zipfile to the next file.
1818 return UNZ_OK if there is no problem
1819 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
1821 extern int unzGoToNextFile (unzFile file)
1827 return UNZ_PARAMERROR;
1829 if (!s->current_file_ok)
1830 return UNZ_END_OF_LIST_OF_FILE;
1831 if (s->num_file+1==s->gi.number_entry)
1832 return UNZ_END_OF_LIST_OF_FILE;
1834 s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
1835 s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
1837 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1838 &s->cur_file_info_internal,
1839 NULL,0,NULL,0,NULL,0);
1840 s->current_file_ok = (err == UNZ_OK);
1846 Try locate the file szFileName in the zipfile.
1847 For the iCaseSensitivity signification, see unzipStringFileNameCompare
1850 UNZ_OK if the file is found. It becomes the current file.
1851 UNZ_END_OF_LIST_OF_FILE if the file is not found
1853 extern int unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
1859 uLong num_fileSaved;
1860 uLong pos_in_central_dirSaved;
1864 return UNZ_PARAMERROR;
1866 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
1867 return UNZ_PARAMERROR;
1870 if (!s->current_file_ok)
1871 return UNZ_END_OF_LIST_OF_FILE;
1873 num_fileSaved = s->num_file;
1874 pos_in_central_dirSaved = s->pos_in_central_dir;
1876 err = unzGoToFirstFile(file);
1878 while (err == UNZ_OK)
1880 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
1881 unzGetCurrentFileInfo(file,NULL,
1882 szCurrentFileName,sizeof(szCurrentFileName)-1,
1884 if (unzStringFileNameCompare(szCurrentFileName,
1885 szFileName,iCaseSensitivity)==0)
1887 err = unzGoToNextFile(file);
1890 s->num_file = num_fileSaved ;
1891 s->pos_in_central_dir = pos_in_central_dirSaved ;
1897 Read the static header of the current zipfile
1898 Check the coherency of the static header and info in the end of central
1899 directory about this file
1900 store in *piSizeVar the size of extra info in static header
1901 (filename and size of extra field data)
1903 static int unzlocal_CheckCurrentFileCoherencyHeader (unz_s* s, uInt* piSizeVar,
1904 uLong *poffset_local_extrafield,
1905 uInt *psize_local_extrafield)
1907 uLong uMagic,uData,uFlags;
1908 uLong size_filename;
1909 uLong size_extra_field;
1913 *poffset_local_extrafield = 0;
1914 *psize_local_extrafield = 0;
1916 if (fseek(s->file,s->cur_file_info_internal.offset_curfile +
1917 s->byte_before_the_zipfile,SEEK_SET)!=0)
1922 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
1924 else if (uMagic!=0x04034b50)
1928 if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
1931 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
1934 if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK)
1937 if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
1939 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
1942 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
1943 (s->cur_file_info.compression_method!=Z_DEFLATED))
1946 if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */
1949 if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */
1951 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
1955 if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */
1957 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
1961 if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */
1963 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
1968 if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK)
1970 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
1973 *piSizeVar += (uInt)size_filename;
1975 if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK)
1977 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
1978 SIZEZIPLOCALHEADER + size_filename;
1979 *psize_local_extrafield = (uInt)size_extra_field;
1981 *piSizeVar += (uInt)size_extra_field;
1987 Open for reading data the current file in the zipfile.
1988 If there is no error and the file is opened, the return value is UNZ_OK.
1990 extern int unzOpenCurrentFile (unzFile file)
1996 file_in_zip_read_info_s* pfile_in_zip_read_info;
1997 uLong offset_local_extrafield; /* offset of the static extra field */
1998 uInt size_local_extrafield; /* size of the static extra field */
2001 return UNZ_PARAMERROR;
2003 if (!s->current_file_ok)
2004 return UNZ_PARAMERROR;
2006 if (s->pfile_in_zip_read != NULL)
2007 unzCloseCurrentFile(file);
2009 if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
2010 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
2011 return UNZ_BADZIPFILE;
2013 pfile_in_zip_read_info = (file_in_zip_read_info_s*)
2014 safe_malloc(sizeof(file_in_zip_read_info_s));
2015 if (pfile_in_zip_read_info==NULL)
2016 return UNZ_INTERNALERROR;
2018 pfile_in_zip_read_info->read_buffer=(char*)safe_malloc(UNZ_BUFSIZE);
2019 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
2020 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
2021 pfile_in_zip_read_info->pos_local_extrafield=0;
2023 if (pfile_in_zip_read_info->read_buffer==NULL)
2025 free(pfile_in_zip_read_info);
2026 return UNZ_INTERNALERROR;
2029 pfile_in_zip_read_info->stream_initialised=0;
2031 if ((s->cur_file_info.compression_method!=0) &&
2032 (s->cur_file_info.compression_method!=Z_DEFLATED))
2034 Store = s->cur_file_info.compression_method==0;
2036 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
2037 pfile_in_zip_read_info->crc32=0;
2038 pfile_in_zip_read_info->compression_method =
2039 s->cur_file_info.compression_method;
2040 pfile_in_zip_read_info->file=s->file;
2041 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
2043 pfile_in_zip_read_info->stream.total_out = 0;
2047 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
2048 pfile_in_zip_read_info->stream.zfree = (free_func)0;
2049 pfile_in_zip_read_info->stream.opaque = (voidp)0;
2051 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
2053 pfile_in_zip_read_info->stream_initialised=1;
2054 /* windowBits is passed < 0 to tell that there is no zlib header.
2055 * Note that in this case inflate *requires* an extra "dummy" byte
2056 * after the compressed stream in order to complete decompression and
2057 * return Z_STREAM_END.
2058 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2059 * size of both compressed and uncompressed data
2062 pfile_in_zip_read_info->rest_read_compressed =
2063 s->cur_file_info.compressed_size ;
2064 pfile_in_zip_read_info->rest_read_uncompressed =
2065 s->cur_file_info.uncompressed_size ;
2068 pfile_in_zip_read_info->pos_in_zipfile =
2069 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
2072 pfile_in_zip_read_info->stream.avail_in = (uInt)0;
2075 s->pfile_in_zip_read = pfile_in_zip_read_info;
2081 Read bytes from the current file.
2082 buf contain buffer where data must be copied
2083 len the size of buf.
2085 return the number of byte copied if somes bytes are copied
2086 return 0 if the end of file was reached
2087 return <0 with error code if there is an error
2088 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
2090 extern int unzReadCurrentFile (unzFile file, void *buf, unsigned len)
2095 file_in_zip_read_info_s* pfile_in_zip_read_info;
2097 return UNZ_PARAMERROR;
2099 pfile_in_zip_read_info=s->pfile_in_zip_read;
2101 if (pfile_in_zip_read_info==NULL)
2102 return UNZ_PARAMERROR;
2105 if ((pfile_in_zip_read_info->read_buffer == NULL))
2106 return UNZ_END_OF_LIST_OF_FILE;
2110 pfile_in_zip_read_info->stream.next_out = (Byte*)buf;
2112 pfile_in_zip_read_info->stream.avail_out = (uInt)len;
2114 if (len>pfile_in_zip_read_info->rest_read_uncompressed)
2115 pfile_in_zip_read_info->stream.avail_out =
2116 (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
2118 while (pfile_in_zip_read_info->stream.avail_out>0)
2120 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
2121 (pfile_in_zip_read_info->rest_read_compressed>0))
2123 uInt uReadThis = UNZ_BUFSIZE;
2124 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
2125 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
2128 if (s->cur_file_info.compressed_size == pfile_in_zip_read_info->rest_read_compressed)
2129 if (fseek(pfile_in_zip_read_info->file,
2130 pfile_in_zip_read_info->pos_in_zipfile +
2131 pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0)
2133 if (fread(pfile_in_zip_read_info->read_buffer,uReadThis,1,
2134 pfile_in_zip_read_info->file)!=1)
2136 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
2138 pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
2140 pfile_in_zip_read_info->stream.next_in =
2141 (Byte*)pfile_in_zip_read_info->read_buffer;
2142 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
2145 if (pfile_in_zip_read_info->compression_method==0)
2148 if (pfile_in_zip_read_info->stream.avail_out <
2149 pfile_in_zip_read_info->stream.avail_in)
2150 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
2152 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
2154 for (i=0;i<uDoCopy;i++)
2155 *(pfile_in_zip_read_info->stream.next_out+i) =
2156 *(pfile_in_zip_read_info->stream.next_in+i);
2158 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
2159 pfile_in_zip_read_info->stream.next_out,
2161 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
2162 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
2163 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
2164 pfile_in_zip_read_info->stream.next_out += uDoCopy;
2165 pfile_in_zip_read_info->stream.next_in += uDoCopy;
2166 pfile_in_zip_read_info->stream.total_out += uDoCopy;
2171 uLong uTotalOutBefore,uTotalOutAfter;
2172 const Byte *bufBefore;
2174 int flush=Z_SYNC_FLUSH;
2176 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
2177 bufBefore = pfile_in_zip_read_info->stream.next_out;
2180 if ((pfile_in_zip_read_info->rest_read_uncompressed ==
2181 pfile_in_zip_read_info->stream.avail_out) &&
2182 (pfile_in_zip_read_info->rest_read_compressed == 0))
2185 err=inflate(&pfile_in_zip_read_info->stream,flush);
2187 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
2188 uOutThis = uTotalOutAfter-uTotalOutBefore;
2190 pfile_in_zip_read_info->crc32 =
2191 crc32(pfile_in_zip_read_info->crc32,bufBefore,
2194 pfile_in_zip_read_info->rest_read_uncompressed -=
2197 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
2199 if (err==Z_STREAM_END)
2200 return (iRead==0) ? UNZ_EOF : iRead;
2213 Give the current position in uncompressed data
2215 extern long unztell (unzFile file)
2218 file_in_zip_read_info_s* pfile_in_zip_read_info;
2220 return UNZ_PARAMERROR;
2222 pfile_in_zip_read_info=s->pfile_in_zip_read;
2224 if (pfile_in_zip_read_info==NULL)
2225 return UNZ_PARAMERROR;
2227 return (long)pfile_in_zip_read_info->stream.total_out;
2232 return 1 if the end of file was reached, 0 elsewhere
2234 extern int unzeof (unzFile file)
2237 file_in_zip_read_info_s* pfile_in_zip_read_info;
2239 return UNZ_PARAMERROR;
2241 pfile_in_zip_read_info=s->pfile_in_zip_read;
2243 if (pfile_in_zip_read_info==NULL)
2244 return UNZ_PARAMERROR;
2246 if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
2255 Read extra field from the current file (opened by unzOpenCurrentFile)
2256 This is the static-header version of the extra field (sometimes, there is
2257 more info in the static-header version than in the central-header)
2259 if buf==NULL, it return the size of the static extra field that can be read
2261 if buf!=NULL, len is the size of the buffer, the extra header is copied in
2263 the return value is the number of bytes copied in buf, or (if <0)
2266 extern int unzGetLocalExtrafield (unzFile file,void *buf,unsigned len)
2269 file_in_zip_read_info_s* pfile_in_zip_read_info;
2274 return UNZ_PARAMERROR;
2276 pfile_in_zip_read_info=s->pfile_in_zip_read;
2278 if (pfile_in_zip_read_info==NULL)
2279 return UNZ_PARAMERROR;
2281 size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
2282 pfile_in_zip_read_info->pos_local_extrafield);
2285 return (int)size_to_read;
2287 if (len>size_to_read)
2288 read_now = (uInt)size_to_read;
2290 read_now = (uInt)len ;
2295 if (fseek(pfile_in_zip_read_info->file,
2296 pfile_in_zip_read_info->offset_local_extrafield +
2297 pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
2300 if (fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
2303 return (int)read_now;
2307 Close the file in zip opened with unzipOpenCurrentFile
2308 Return UNZ_CRCERROR if all the file was read but the CRC is not good
2310 extern int unzCloseCurrentFile (unzFile file)
2315 file_in_zip_read_info_s* pfile_in_zip_read_info;
2317 return UNZ_PARAMERROR;
2319 pfile_in_zip_read_info=s->pfile_in_zip_read;
2321 if (pfile_in_zip_read_info==NULL)
2322 return UNZ_PARAMERROR;
2325 if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
2327 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
2332 free(pfile_in_zip_read_info->read_buffer);
2333 pfile_in_zip_read_info->read_buffer = NULL;
2334 if (pfile_in_zip_read_info->stream_initialised)
2335 inflateEnd(&pfile_in_zip_read_info->stream);
2337 pfile_in_zip_read_info->stream_initialised = 0;
2338 free(pfile_in_zip_read_info);
2340 s->pfile_in_zip_read=NULL;
2347 Get the global comment string of the ZipFile, in the szComment buffer.
2348 uSizeBuf is the size of the szComment buffer.
2349 return the number of byte copied or an error code <0
2351 extern int unzGetGlobalComment (unzFile file, char *szComment, uLong uSizeBuf)
2356 return UNZ_PARAMERROR;
2359 uReadThis = uSizeBuf;
2360 if (uReadThis>s->gi.size_comment)
2361 uReadThis = s->gi.size_comment;
2363 if (fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
2369 if (fread(szComment,(uInt)uReadThis,1,s->file)!=1)
2373 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
2374 *(szComment+s->gi.size_comment)='\0';
2375 return (int)uReadThis;
2378 /* crc32.c -- compute the CRC-32 of a data stream
2379 * Copyright (C) 1995-1998 Mark Adler
2380 * For conditions of distribution and use, see copyright notice in zlib.h
2384 #ifdef DYNAMIC_CRC_TABLE
2386 static int crc_table_empty = 1;
2387 static uLong crc_table[256];
2388 static void make_crc_table OF((void));
2391 Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
2392 x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
2394 Polynomials over GF(2) are represented in binary, one bit per coefficient,
2395 with the lowest powers in the most significant bit. Then adding polynomials
2396 is just exclusive-or, and multiplying a polynomial by x is a right shift by
2397 one. If we call the above polynomial p, and represent a byte as the
2398 polynomial q, also with the lowest power in the most significant bit (so the
2399 byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
2400 where a mod b means the remainder after dividing a by b.
2402 This calculation is done using the shift-register method of multiplying and
2403 taking the remainder. The register is initialized to zero, and for each
2404 incoming bit, x^32 is added mod p to the register if the bit is a one (where
2405 x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
2406 x (which is shifting right by one and adding x^32 mod p if the bit shifted
2407 out is a one). We start with the highest power (least significant bit) of
2408 q and repeat for all eight bits of q.
2410 The table is simply the CRC of all possible eight bit values. This is all
2411 the information needed to generate CRC's on data a byte at a time for all
2412 combinations of CRC register values and incoming bytes.
2414 static void make_crc_table()
2418 uLong poly; /* polynomial exclusive-or pattern */
2419 /* terms of polynomial defining this crc (except x^32): */
2420 static const Byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
2422 /* make exclusive-or pattern from polynomial (0xedb88320L) */
2424 for (n = 0; n < sizeof(p)/sizeof(Byte); n++)
2425 poly |= 1L << (31 - p[n]);
2427 for (n = 0; n < 256; n++)
2430 for (k = 0; k < 8; k++)
2431 c = c & 1 ? poly ^ (c >> 1) : c >> 1;
2434 crc_table_empty = 0;
2437 /* ========================================================================
2438 * Table of CRC-32's of all single-byte values (made by make_crc_table)
2440 static const uLong crc_table[256] = {
2441 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
2442 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
2443 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
2444 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
2445 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
2446 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
2447 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
2448 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
2449 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
2450 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
2451 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
2452 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
2453 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
2454 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
2455 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
2456 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
2457 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
2458 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
2459 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
2460 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
2461 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
2462 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
2463 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
2464 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
2465 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
2466 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
2467 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
2468 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
2469 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
2470 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
2471 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
2472 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
2473 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
2474 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
2475 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
2476 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
2477 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
2478 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
2479 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
2480 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
2481 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
2482 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
2483 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
2484 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
2485 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
2486 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
2487 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
2488 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
2489 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
2490 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
2491 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
2496 /* =========================================================================
2497 * This function can be used by asm versions of crc32()
2500 const uLong * get_crc_table()
2502 #ifdef DYNAMIC_CRC_TABLE
2503 if (crc_table_empty) make_crc_table();
2505 return (const uLong *)crc_table;
2509 /* ========================================================================= */
2510 #define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
2511 #define DO2(buf) DO1(buf); DO1(buf);
2512 #define DO4(buf) DO2(buf); DO2(buf);
2513 #define DO8(buf) DO4(buf); DO4(buf);
2515 /* ========================================================================= */
2517 uLong crc32(uLong crc, const Byte *buf, uInt len)
2519 if (buf == Z_NULL) return 0L;
2520 #ifdef DYNAMIC_CRC_TABLE
2521 if (crc_table_empty)
2524 crc = crc ^ 0xffffffffL;
2533 return crc ^ 0xffffffffL;
2537 /* infblock.h -- header to use infblock.c
2538 * Copyright (C) 1995-1998 Mark Adler
2539 * For conditions of distribution and use, see copyright notice in zlib.h
2542 /* WARNING: this file should *not* be used by applications. It is
2543 part of the implementation of the compression library and is
2544 subject to change. Applications should only use zlib.h.
2547 struct inflate_blocks_state;
2548 typedef struct inflate_blocks_state inflate_blocks_statef;
2550 extern inflate_blocks_statef * inflate_blocks_new OF((
2552 check_func c, /* check function */
2553 uInt w)); /* window size */
2555 extern int inflate_blocks OF((
2556 inflate_blocks_statef *,
2558 int)); /* initial return code */
2560 extern void inflate_blocks_reset OF((
2561 inflate_blocks_statef *,
2563 uLong *)); /* check value on output */
2565 extern int inflate_blocks_free OF((
2566 inflate_blocks_statef *,
2569 extern void inflate_set_dictionary OF((
2570 inflate_blocks_statef *s,
2571 const Byte *d, /* dictionary */
2572 uInt n)); /* dictionary length */
2574 extern int inflate_blocks_sync_point OF((
2575 inflate_blocks_statef *s));
2577 /* simplify the use of the inflate_huft type with some defines */
2578 #define exop word.what.Exop
2579 #define bits word.what.Bits
2581 /* Table for deflate from PKZIP's appnote.txt. */
2582 static const uInt border[] = { /* Order of the bit length code lengths */
2583 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
2585 /* inftrees.h -- header to use inftrees.c
2586 * Copyright (C) 1995-1998 Mark Adler
2587 * For conditions of distribution and use, see copyright notice in zlib.h
2590 /* WARNING: this file should *not* be used by applications. It is
2591 part of the implementation of the compression library and is
2592 subject to change. Applications should only use zlib.h.
2595 /* Huffman code lookup table entry--this entry is four bytes for machines
2596 that have 16-bit pointers (e.g. PC's in the small or medium model). */
2598 typedef struct inflate_huft_s inflate_huft;
2600 struct inflate_huft_s {
2603 Byte Exop; /* number of extra bits or operation */
2604 Byte Bits; /* number of bits in this code or subcode */
2606 uInt pad; /* pad structure to a power of 2 (4 bytes for */
2607 } word; /* 16-bit, 8 bytes for 32-bit int's) */
2608 uInt base; /* literal, length base, distance base,
2612 /* Maximum size of dynamic tree. The maximum found in a long but non-
2613 exhaustive search was 1004 huft structures (850 for length/literals
2614 and 154 for distances, the latter actually the result of an
2615 exhaustive search). The actual maximum is not known, but the
2616 value below is more than safe. */
2619 extern int inflate_trees_bits OF((
2620 uInt *, /* 19 code lengths */
2621 uInt *, /* bits tree desired/actual depth */
2622 inflate_huft * *, /* bits tree result */
2623 inflate_huft *, /* space for trees */
2624 z_streamp)); /* for messages */
2626 extern int inflate_trees_dynamic OF((
2627 uInt, /* number of literal/length codes */
2628 uInt, /* number of distance codes */
2629 uInt *, /* that many (total) code lengths */
2630 uInt *, /* literal desired/actual bit depth */
2631 uInt *, /* distance desired/actual bit depth */
2632 inflate_huft * *, /* literal/length tree result */
2633 inflate_huft * *, /* distance tree result */
2634 inflate_huft *, /* space for trees */
2635 z_streamp)); /* for messages */
2637 extern int inflate_trees_fixed OF((
2638 uInt *, /* literal desired/actual bit depth */
2639 uInt *, /* distance desired/actual bit depth */
2640 inflate_huft * *, /* literal/length tree result */
2641 inflate_huft * *, /* distance tree result */
2642 z_streamp)); /* for memory allocation */
2645 /* infcodes.h -- header to use infcodes.c
2646 * Copyright (C) 1995-1998 Mark Adler
2647 * For conditions of distribution and use, see copyright notice in zlib.h
2650 /* WARNING: this file should *not* be used by applications. It is
2651 part of the implementation of the compression library and is
2652 subject to change. Applications should only use zlib.h.
2655 struct inflate_codes_state;
2656 typedef struct inflate_codes_state inflate_codes_statef;
2658 extern inflate_codes_statef *inflate_codes_new OF((
2660 inflate_huft *, inflate_huft *,
2663 extern int inflate_codes OF((
2664 inflate_blocks_statef *,
2668 extern void inflate_codes_free OF((
2669 inflate_codes_statef *,
2672 /* infutil.h -- types and macros common to blocks and codes
2673 * Copyright (C) 1995-1998 Mark Adler
2674 * For conditions of distribution and use, see copyright notice in zlib.h
2677 /* WARNING: this file should *not* be used by applications. It is
2678 part of the implementation of the compression library and is
2679 subject to change. Applications should only use zlib.h.
2686 TYPE, /* get type bits (3, including end bit) */
2687 LENS, /* get lengths for stored */
2688 STORED, /* processing stored block */
2689 TABLE, /* get table lengths */
2690 BTREE, /* get bit lengths tree for a dynamic block */
2691 DTREE, /* get length, distance trees for a dynamic block */
2692 CODES, /* processing fixed or dynamic block */
2693 DRY, /* output remaining window bytes */
2694 DONE, /* finished last block, done */
2695 BAD} /* got a data error--stuck here */
2698 /* inflate blocks semi-private state */
2699 struct inflate_blocks_state {
2702 inflate_block_mode mode; /* current inflate_block mode */
2704 /* mode dependent information */
2706 uInt left; /* if STORED, bytes left to copy */
2708 uInt table; /* table lengths (14 bits) */
2709 uInt index; /* index into blens (or border) */
2710 uInt *blens; /* bit lengths of codes */
2711 uInt bb; /* bit length tree depth */
2712 inflate_huft *tb; /* bit length decoding tree */
2713 } trees; /* if DTREE, decoding info for trees */
2715 inflate_codes_statef
2717 } decode; /* if CODES, current state */
2718 } sub; /* submode */
2719 uInt last; /* true if this block is the last block */
2721 /* mode independent information */
2722 uInt bitk; /* bits in bit buffer */
2723 uLong bitb; /* bit buffer */
2724 inflate_huft *hufts; /* single safe_malloc for tree space */
2725 Byte *window; /* sliding window */
2726 Byte *end; /* one byte after sliding window */
2727 Byte *read; /* window read pointer */
2728 Byte *write; /* window write pointer */
2729 check_func checkfn; /* check function */
2730 uLong check; /* check on output */
2735 /* defines for inflate input/output */
2736 /* update pointers and return */
2737 #define UPDBITS {s->bitb=b;s->bitk=k;}
2738 #define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;}
2739 #define UPDOUT {s->write=q;}
2740 #define UPDATE {UPDBITS UPDIN UPDOUT}
2741 #define LEAVE {UPDATE return inflate_flush(s,z,r);}
2742 /* get bytes and bits */
2743 #define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;}
2744 #define NEEDBYTE {if(n)r=Z_OK;else LEAVE}
2745 #define NEXTBYTE (n--,*p++)
2746 #define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}}
2747 #define DUMPBITS(j) {b>>=(j);k-=(j);}
2749 #define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q)
2750 #define LOADOUT {q=s->write;m=(uInt)WAVAIL;}
2751 #define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}}
2752 #define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT}
2753 #define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;}
2754 #define OUTBYTE(a) {*q++=(Byte)(a);m--;}
2755 /* load static pointers */
2756 #define LOAD {LOADIN LOADOUT}
2758 /* masks for lower bits (size given to avoid silly warnings with Visual C++) */
2759 extern uInt inflate_mask[17];
2761 /* copy as much as possible from the sliding window to the output area */
2762 extern int inflate_flush OF((
2763 inflate_blocks_statef *,
2771 Notes beyond the 1.93a appnote.txt:
2773 1. Distance pointers never point before the beginning of the output
2775 2. Distance pointers can point back across blocks, up to 32k away.
2776 3. There is an implied maximum of 7 bits for the bit length table and
2777 15 bits for the actual data.
2778 4. If only one code exists, then it is encoded using one bit. (Zero
2779 would be more efficient, but perhaps a little confusing.) If two
2780 codes exist, they are coded using one bit each (0 and 1).
2781 5. There is no way of sending zero distance codes--a dummy must be
2782 sent if there are none. (History: a pre 2.0 version of PKZIP would
2783 store blocks with no distance codes, but this was discovered to be
2784 too harsh a criterion.) Valid only for 1.93a. 2.04c does allow
2785 zero distance codes, which is sent as one code of zero bits in
2787 6. There are up to 286 literal/length codes. Code 256 represents the
2788 end-of-block. Note however that the static length tree defines
2789 288 codes just to fill out the Huffman codes. Codes 286 and 287
2790 cannot be used though, since there is no length base or extra bits
2791 defined for them. Similarily, there are up to 30 distance codes.
2792 However, static trees define 32 codes (all 5 bits) to fill out the
2793 Huffman codes, but the last two had better not show up in the data.
2794 7. Unzip can check dynamic Huffman blocks for complete code sets.
2795 The exception is that a single code would not be complete (see #4).
2796 8. The five bits following the block type is really the number of
2797 literal codes sent minus 257.
2798 9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
2799 (1+6+6). Therefore, to output three times the length, you output
2800 three codes (1+1+1), whereas to output four times the same length,
2801 you only need two codes (1+3). Hmm.
2802 10. In the tree reconstruction algorithm, Code = Code + Increment
2803 only if BitLength(i) is not zero. (Pretty obvious.)
2804 11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19)
2805 12. Note: length code 284 can represent 227-258, but length code 285
2806 really is 258. The last length deserves its own, short code
2807 since it gets used a lot in very redundant files. The length
2808 258 is special since 258 - 3 (the min match length) is 255.
2809 13. The literal/length and distance code bit lengths are read as a
2810 single stream of lengths. It is possible (and advantageous) for
2811 a repeat code (16, 17, or 18) to go across the boundary between
2812 the two sets of lengths.
2817 void inflate_blocks_reset(inflate_blocks_statef *s, z_streamp z, uLong *c)
2821 if (s->mode == BTREE || s->mode == DTREE)
2822 ZFREE(z, s->sub.trees.blens);
2823 if (s->mode == CODES)
2824 inflate_codes_free(s->sub.decode.codes, z);
2828 s->read = s->write = s->window;
2829 if (s->checkfn != Z_NULL)
2830 z->adler = s->check = (*s->checkfn)(0L, (const Byte *)Z_NULL, 0);
2831 Tracev(("inflate: blocks reset\n"));
2836 inflate_blocks_statef *inflate_blocks_new(z_streamp z, check_func c, uInt w)
2838 inflate_blocks_statef *s;
2840 if ((s = (inflate_blocks_statef *)ZALLOC
2841 (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
2844 (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL)
2849 if ((s->window = (Byte *)ZALLOC(z, 1, w)) == Z_NULL)
2855 s->end = s->window + w;
2858 Tracev(("inflate: blocks allocated\n"));
2859 inflate_blocks_reset(s, z, Z_NULL);
2865 int inflate_blocks(inflate_blocks_statef *s, z_streamp z, int r)
2867 uInt t; /* temporary storage */
2868 uLong b; /* bit buffer */
2869 uInt k; /* bits in bit buffer */
2870 Byte *p; /* input data pointer */
2871 uInt n; /* bytes available there */
2872 Byte *q; /* output window write pointer */
2873 uInt m; /* bytes to end of window or read pointer */
2875 /* copy input/output information to locals (UPDATE macro restores) */
2878 /* process input based on current state */
2879 while (1) switch (s->mode)
2887 case 0: /* stored */
2888 Tracev(("inflate: stored block%s\n",
2889 s->last ? " (last)" : ""));
2891 t = k & 7; /* go to byte boundary */
2893 s->mode = LENS; /* get length of stored block */
2896 Tracev(("inflate: fixed codes block%s\n",
2897 s->last ? " (last)" : ""));
2900 inflate_huft *tl, *td;
2902 inflate_trees_fixed(&bl, &bd, &tl, &td, z);
2903 s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
2904 if (s->sub.decode.codes == Z_NULL)
2913 case 2: /* dynamic */
2914 Tracev(("inflate: dynamic codes block%s\n",
2915 s->last ? " (last)" : ""));
2919 case 3: /* illegal */
2922 z->msg = (char*)"invalid block type";
2929 if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
2932 z->msg = (char*)"invalid stored block lengths";
2936 s->sub.left = (uInt)b & 0xffff;
2937 b = k = 0; /* dump bits */
2938 Tracev(("inflate: stored length %u\n", s->sub.left));
2939 s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE);
2951 if ((s->sub.left -= t) != 0)
2953 Tracev(("inflate: stored end, %lu total out\n",
2954 z->total_out + (q >= s->read ? q - s->read :
2955 (s->end - s->read) + (q - s->window))));
2956 s->mode = s->last ? DRY : TYPE;
2960 s->sub.trees.table = t = (uInt)b & 0x3fff;
2961 #ifndef PKZIP_BUG_WORKAROUND
2962 if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
2965 z->msg = (char*)"too many length or distance symbols";
2970 t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
2971 if ((s->sub.trees.blens = (uInt*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
2977 s->sub.trees.index = 0;
2978 Tracev(("inflate: table sizes ok\n"));
2981 while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
2984 s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
2987 while (s->sub.trees.index < 19)
2988 s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
2989 s->sub.trees.bb = 7;
2990 t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
2991 &s->sub.trees.tb, s->hufts, z);
2994 ZFREE(z, s->sub.trees.blens);
2996 if (r == Z_DATA_ERROR)
3000 s->sub.trees.index = 0;
3001 Tracev(("inflate: bits tree ok\n"));
3004 while (t = s->sub.trees.table,
3005 s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
3010 t = s->sub.trees.bb;
3012 h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
3018 s->sub.trees.blens[s->sub.trees.index++] = c;
3020 else /* c == 16..18 */
3022 i = c == 18 ? 7 : c - 14;
3023 j = c == 18 ? 11 : 3;
3026 j += (uInt)b & inflate_mask[i];
3028 i = s->sub.trees.index;
3029 t = s->sub.trees.table;
3030 if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
3033 ZFREE(z, s->sub.trees.blens);
3035 z->msg = (char*)"invalid bit length repeat";
3039 c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
3041 s->sub.trees.blens[i++] = c;
3043 s->sub.trees.index = i;
3046 s->sub.trees.tb = Z_NULL;
3049 inflate_huft *tl, *td;
3050 inflate_codes_statef *c;
3052 bl = 9; /* must be <= 9 for lookahead assumptions */
3053 bd = 6; /* must be <= 9 for lookahead assumptions */
3054 t = s->sub.trees.table;
3055 t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
3056 s->sub.trees.blens, &bl, &bd, &tl, &td,
3058 ZFREE(z, s->sub.trees.blens);
3061 if (t == (uInt)Z_DATA_ERROR)
3066 Tracev(("inflate: trees ok\n"));
3067 if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
3072 s->sub.decode.codes = c;
3077 if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
3078 return inflate_flush(s, z, r);
3080 inflate_codes_free(s->sub.decode.codes, z);
3082 Tracev(("inflate: codes end, %lu total out\n",
3083 z->total_out + (q >= s->read ? q - s->read :
3084 (s->end - s->read) + (q - s->window))));
3093 if (s->read != s->write)
3110 int inflate_blocks_free(inflate_blocks_statef *s, z_streamp z)
3112 inflate_blocks_reset(s, z, Z_NULL);
3113 ZFREE(z, s->window);
3116 Tracev(("inflate: blocks freed\n"));
3122 void inflate_set_dictionary(inflate_blocks_statef *s, const Byte *d, uInt n)
3124 zmemcpy(s->window, d, n);
3125 s->read = s->write = s->window + n;
3129 /* Returns true if inflate is currently at the end of a block generated
3130 * by Z_SYNC_FLUSH or Z_FULL_FLUSH.
3131 * IN assertion: s != Z_NULL
3134 int inflate_blocks_sync_point(inflate_blocks_statef *s)
3136 return s->mode == LENS;
3140 /* And'ing with mask[n] masks the lower n bits */
3141 uInt inflate_mask[17] = {
3143 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
3144 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
3147 /* copy as much as possible from the sliding window to the output area */
3149 int inflate_flush(inflate_blocks_statef *s, z_streamp z, int r)
3155 /* static copies of source and destination pointers */
3159 /* compute number of bytes to copy as as end of window */
3160 n = (uInt)((q <= s->write ? s->write : s->end) - q);
3161 if (n > z->avail_out) n = z->avail_out;
3162 if (n && r == Z_BUF_ERROR) r = Z_OK;
3164 /* update counters */
3168 /* update check information */
3169 if (s->checkfn != Z_NULL)
3170 z->adler = s->check = (*s->checkfn)(s->check, q, n);
3172 /* copy as as end of window */
3177 /* see if more to copy at beginning of window */
3182 if (s->write == s->end)
3183 s->write = s->window;
3185 /* compute bytes to copy */
3186 n = (uInt)(s->write - q);
3187 if (n > z->avail_out) n = z->avail_out;
3188 if (n && r == Z_BUF_ERROR) r = Z_OK;
3190 /* update counters */
3194 /* update check information */
3195 if (s->checkfn != Z_NULL)
3196 z->adler = s->check = (*s->checkfn)(s->check, q, n);
3204 /* update pointers */
3213 /* inftrees.c -- generate Huffman trees for efficient decoding
3214 * Copyright (C) 1995-1998 Mark Adler
3215 * For conditions of distribution and use, see copyright notice in zlib.h
3219 const char inflate_copyright[] =
3220 " inflate 1.1.3 Copyright 1995-1998 Mark Adler ";
3224 If you use the zlib library in a product, an acknowledgment is welcome
3225 in the documentation of your product. If for some reason you cannot
3226 include such an acknowledgment, I would appreciate that you keep this
3227 copyright string in the executable of your product.
3230 /* simplify the use of the inflate_huft type with some defines */
3231 #define exop word.what.Exop
3232 #define bits word.what.Bits
3235 static int huft_build OF((
3236 uInt *, /* code lengths in bits */
3237 uInt, /* number of codes */
3238 uInt, /* number of "simple" codes */
3239 const uInt *, /* list of base values for non-simple codes */
3240 const uInt *, /* list of extra bits for non-simple codes */
3241 inflate_huft **, /* result: starting table */
3242 uInt *, /* maximum lookup bits (returns actual) */
3243 inflate_huft *, /* space for trees */
3244 uInt *, /* hufts used in space */
3245 uInt * )); /* space for values */
3247 /* Tables for deflate from PKZIP's appnote.txt. */
3248 static const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
3249 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
3250 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
3251 /* see note #13 above about 258 */
3252 static const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
3253 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
3254 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112}; /* 112==invalid */
3255 static const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
3256 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
3257 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
3258 8193, 12289, 16385, 24577};
3259 static const uInt cpdext[30] = { /* Extra bits for distance codes */
3260 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
3261 7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
3265 Huffman code decoding is performed using a multi-level table lookup.
3266 The fastest way to decode is to simply build a lookup table whose
3267 size is determined by the longest code. However, the time it takes
3268 to build this table can also be a factor if the data being decoded
3269 is not very long. The most common codes are necessarily the
3270 shortest codes, so those codes dominate the decoding time, and hence
3271 the speed. The idea is you can have a shorter table that decodes the
3272 shorter, more probable codes, and then point to subsidiary tables for
3273 the longer codes. The time it costs to decode the longer codes is
3274 then traded against the time it takes to make longer tables.
3276 This results of this trade are in the variables lbits and dbits
3277 below. lbits is the number of bits the first level table for literal/
3278 length codes can decode in one step, and dbits is the same thing for
3279 the distance codes. Subsequent tables are also less than or equal to
3280 those sizes. These values may be adjusted either when all of the
3281 codes are shorter than that, in which case the longest code length in
3282 bits is used, or when the shortest code is *longer* than the requested
3283 table size, in which case the length of the shortest code in bits is
3286 There are two different values for the two tables, since they code a
3287 different number of possibilities each. The literal/length table
3288 codes 286 possible values, or in a flat code, a little over eight
3289 bits. The distance table codes 30 possible values, or a little less
3290 than five bits, flat. The optimum values for speed end up being
3291 about one bit more than those, so lbits is 8+1 and dbits is 5+1.
3292 The optimum values may differ though from machine to machine, and
3293 possibly even between compilers. Your mileage may vary.
3297 /* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
3298 #define BMAX 15 /* maximum bit length of any code */
3300 static int huft_build(uInt *b, uInt n, uInt s, const uInt *d, const uInt *e, inflate_huft ** t, uInt *m, inflate_huft *hp, uInt *hn, uInt *v)
3301 //uInt *b; /* code lengths in bits (all assumed <= BMAX) */
3302 //uInt n; /* number of codes (assumed <= 288) */
3303 //uInt s; /* number of simple-valued codes (0..s-1) */
3304 //const uInt *d; /* list of base values for non-simple codes */
3305 //const uInt *e; /* list of extra bits for non-simple codes */
3306 //inflate_huft ** t; /* result: starting table */
3307 //uInt *m; /* maximum lookup bits, returns actual */
3308 //inflate_huft *hp; /* space for trees */
3309 //uInt *hn; /* hufts used in space */
3310 //uInt *v; /* working area: values in order of bit length */
3311 /* Given a list of code lengths and a maximum table size, make a set of
3312 tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
3313 if the given code set is incomplete (the tables are still built in this
3314 case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
3315 lengths), or Z_MEM_ERROR if not enough memory. */
3318 uInt a; /* counter for codes of length k */
3319 uInt c[BMAX+1]; /* bit length count table */
3320 uInt f; /* i repeats in table every f entries */
3321 int g; /* maximum code length */
3322 int h; /* table level */
3323 register uInt i; /* counter, current code */
3324 register uInt j; /* counter */
3325 register int k; /* number of bits in current code */
3326 int l; /* bits per table (returned in m) */
3327 uInt mask; /* (1 << w) - 1, to avoid cc -O bug on HP */
3328 register uInt *p; /* pointer into c[], b[], or v[] */
3329 inflate_huft *q; /* points to current table */
3330 struct inflate_huft_s r; /* table entry for structure assignment */
3331 inflate_huft *u[BMAX]; /* table stack */
3332 register int w; /* bits before this table == (l * h) */
3333 uInt x[BMAX+1]; /* bit offsets, then code stack */
3334 uInt *xp; /* pointer into x */
3335 int y; /* number of dummy codes added */
3336 uInt z; /* number of entries in current table */
3339 /* Generate counts for each bit length */
3341 #define C0 *p++ = 0;
3342 #define C2 C0 C0 C0 C0
3343 #define C4 C2 C2 C2 C2
3344 C4 /* clear c[]--assume BMAX+1 is 16 */
3347 c[*p++]++; /* assume all entries <= BMAX */
3349 if (c[0] == n) /* null input--all zero length codes */
3351 *t = (inflate_huft *)Z_NULL;
3357 /* Find minimum and maximum length, bound *m by those */
3359 for (j = 1; j <= BMAX; j++)
3362 k = j; /* minimum code length */
3365 for (i = BMAX; i; i--)
3368 g = i; /* maximum code length */
3374 /* Adjust last length count to fill out codes, if needed */
3375 for (y = 1 << j; j < i; j++, y <<= 1)
3376 if ((y -= c[j]) < 0)
3377 return Z_DATA_ERROR;
3378 if ((y -= c[i]) < 0)
3379 return Z_DATA_ERROR;
3383 /* Generate starting offsets into the value table for each length */
3385 p = c + 1; xp = x + 2;
3386 while (--i) { /* note that i == g from above */
3387 *xp++ = (j += *p++);
3391 /* Make a table of values in order of bit lengths */
3394 if ((j = *p++) != 0)
3397 n = x[g]; /* set n to length of v */
3400 /* Generate the Huffman codes and for each, make the table entries */
3401 x[0] = i = 0; /* first Huffman code is zero */
3402 p = v; /* grab values in bit order */
3403 h = -1; /* no tables yet--level -1 */
3404 w = -l; /* bits decoded == (l * h) */
3405 u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */
3406 q = (inflate_huft *)Z_NULL; /* ditto */
3409 /* go through the bit lengths (k already is bits in shortest code) */
3415 /* here i is the Huffman code of length k bits for value *p */
3416 /* make tables up to required level */
3420 w += l; /* previous table always l bits */
3422 /* compute minimum size table less than or equal to l bits */
3424 z = z > (uInt)l ? (uInt)l : z; /* table size upper limit */
3425 if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */
3426 { /* too few codes for k-w bit table */
3427 f -= a + 1; /* deduct codes from patterns left */
3430 while (++j < z) /* try smaller tables up to z bits */
3432 if ((f <<= 1) <= *++xp)
3433 break; /* enough codes to use up j bits */
3434 f -= *xp; /* else deduct codes from patterns */
3437 z = 1 << j; /* table entries for j-bit table */
3439 /* allocate new table */
3440 if (*hn + z > MANY) /* (note: doesn't matter for fixed) */
3441 return Z_MEM_ERROR; /* not enough memory */
3442 u[h] = q = hp + *hn;
3445 /* connect to last table, if there is one */
3448 x[h] = i; /* save pattern for backing up */
3449 r.bits = (Byte)l; /* bits to dump before this table */
3450 r.exop = (Byte)j; /* bits in this table */
3452 r.base = (uInt)(q - u[h-1] - j); /* offset to this table */
3453 u[h-1][j] = r; /* connect to last table */
3456 *t = q; /* first table is returned result */
3459 /* set up table entry in r */
3460 r.bits = (Byte)(k - w);
3462 r.exop = 128 + 64; /* out of values--invalid code */
3465 r.exop = (Byte)(*p < 256 ? 0 : 32 + 64); /* 256 is end-of-block */
3466 r.base = *p++; /* simple code is just the value */
3470 r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */
3471 r.base = d[*p++ - s];
3474 /* fill code-like entries with r */
3476 for (j = i >> w; j < z; j += f)
3479 /* backwards increment the k-bit code i */
3480 for (j = 1 << (k - 1); i & j; j >>= 1)
3484 /* backup over finished tables */
3485 mask = (1 << w) - 1; /* needed on HP, cc -O bug */
3486 while ((i & mask) != x[h])
3488 h--; /* don't need to update q */
3490 mask = (1 << w) - 1;
3496 /* Return Z_BUF_ERROR if we were given an incomplete table */
3497 return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
3502 int inflate_trees_bits(uInt *c, uInt *bb, inflate_huft * *tb, inflate_huft *hp, z_streamp z)
3503 //uInt *c; /* 19 code lengths */
3504 //uInt *bb; /* bits tree desired/actual depth */
3505 //inflate_huft * *tb; /* bits tree result */
3506 //inflate_huft *hp; /* space for trees */
3507 //z_streamp z; /* for messages */
3510 uInt hn = 0; /* hufts used in space */
3511 uInt *v; /* work area for huft_build */
3513 if ((v = (uInt*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL)
3515 r = huft_build(c, 19, 19, (uInt*)Z_NULL, (uInt*)Z_NULL,
3516 tb, bb, hp, &hn, v);
3517 if (r == Z_DATA_ERROR)
3518 z->msg = (char*)"oversubscribed dynamic bit lengths tree";
3519 else if (r == Z_BUF_ERROR || *bb == 0)
3521 z->msg = (char*)"incomplete dynamic bit lengths tree";
3530 int inflate_trees_dynamic(uInt nl, uInt nd, uInt *c, uInt *bl, uInt *bd, inflate_huft * *tl, inflate_huft * *td, inflate_huft *hp, z_streamp z)
3531 //uInt nl; /* number of literal/length codes */
3532 //uInt nd; /* number of distance codes */
3533 //uInt *c; /* that many (total) code lengths */
3534 //uInt *bl; /* literal desired/actual bit depth */
3535 //uInt *bd; /* distance desired/actual bit depth */
3536 //inflate_huft * *tl; /* literal/length tree result */
3537 //inflate_huft * *td; /* distance tree result */
3538 //inflate_huft *hp; /* space for trees */
3539 //z_streamp z; /* for messages */
3542 uInt hn = 0; /* hufts used in space */
3543 uInt *v; /* work area for huft_build */
3545 /* allocate work area */
3546 if ((v = (uInt*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
3549 /* build literal/length tree */
3550 r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);
3551 if (r != Z_OK || *bl == 0)
3553 if (r == Z_DATA_ERROR)
3554 z->msg = (char*)"oversubscribed literal/length tree";
3555 else if (r != Z_MEM_ERROR)
3557 z->msg = (char*)"incomplete literal/length tree";
3564 /* build distance tree */
3565 r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);
3566 if (r != Z_OK || (*bd == 0 && nl > 257))
3568 if (r == Z_DATA_ERROR)
3569 z->msg = (char*)"oversubscribed distance tree";
3570 else if (r == Z_BUF_ERROR) {
3571 #ifdef PKZIP_BUG_WORKAROUND
3575 z->msg = (char*)"incomplete distance tree";
3578 else if (r != Z_MEM_ERROR)
3580 z->msg = (char*)"empty distance tree with lengths";
3594 /* inffixed.h -- table for decoding fixed codes
3595 * Generated automatically by the maketree.c program
3598 /* WARNING: this file should *not* be used by applications. It is
3599 part of the implementation of the compression library and is
3600 subject to change. Applications should only use zlib.h.
3603 static uInt fixed_bl = 9;
3604 static uInt fixed_bd = 5;
3605 static inflate_huft fixed_tl[] = {
3606 {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
3607 {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},192},
3608 {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},160},
3609 {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},224},
3610 {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},144},
3611 {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},208},
3612 {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},176},
3613 {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},240},
3614 {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
3615 {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},200},
3616 {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},168},
3617 {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},232},
3618 {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},152},
3619 {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},216},
3620 {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},184},
3621 {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},248},
3622 {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
3623 {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},196},
3624 {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},164},
3625 {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},228},
3626 {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},148},
3627 {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},212},
3628 {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},180},
3629 {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},244},
3630 {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
3631 {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},204},
3632 {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},172},
3633 {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},236},
3634 {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},156},
3635 {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},220},
3636 {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},188},
3637 {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},252},
3638 {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
3639 {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},194},
3640 {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},162},
3641 {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},226},
3642 {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},146},
3643 {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},210},
3644 {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},178},
3645 {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},242},
3646 {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
3647 {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},202},
3648 {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},170},
3649 {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},234},
3650 {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},154},
3651 {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},218},
3652 {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},186},
3653 {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},250},
3654 {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
3655 {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},198},
3656 {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},166},
3657 {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},230},
3658 {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},150},
3659 {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},214},
3660 {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},182},
3661 {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},246},
3662 {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
3663 {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},206},
3664 {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},174},
3665 {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},238},
3666 {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},158},
3667 {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},222},
3668 {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},190},
3669 {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},254},
3670 {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
3671 {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},193},
3672 {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},161},
3673 {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},225},
3674 {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},145},
3675 {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},209},
3676 {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},177},
3677 {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},241},
3678 {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
3679 {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},201},
3680 {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},169},
3681 {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},233},
3682 {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},153},
3683 {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},217},
3684 {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},185},
3685 {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},249},
3686 {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
3687 {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},197},
3688 {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},165},
3689 {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},229},
3690 {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},149},
3691 {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},213},
3692 {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},181},
3693 {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},245},
3694 {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
3695 {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},205},
3696 {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},173},
3697 {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},237},
3698 {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},157},
3699 {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},221},
3700 {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},189},
3701 {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},253},
3702 {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
3703 {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},195},
3704 {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},163},
3705 {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},227},
3706 {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},147},
3707 {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},211},
3708 {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},179},
3709 {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},243},
3710 {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
3711 {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},203},
3712 {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},171},
3713 {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},235},
3714 {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},155},
3715 {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},219},
3716 {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},187},
3717 {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},251},
3718 {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
3719 {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},199},
3720 {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},167},
3721 {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},231},
3722 {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},151},
3723 {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},215},
3724 {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},183},
3725 {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},247},
3726 {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
3727 {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},207},
3728 {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},175},
3729 {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},239},
3730 {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},159},
3731 {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},223},
3732 {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},191},
3733 {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},255}
3735 static inflate_huft fixed_td[] = {
3736 {{{80,5}},1}, {{{87,5}},257}, {{{83,5}},17}, {{{91,5}},4097},
3737 {{{81,5}},5}, {{{89,5}},1025}, {{{85,5}},65}, {{{93,5}},16385},
3738 {{{80,5}},3}, {{{88,5}},513}, {{{84,5}},33}, {{{92,5}},8193},
3739 {{{82,5}},9}, {{{90,5}},2049}, {{{86,5}},129}, {{{192,5}},24577},
3740 {{{80,5}},2}, {{{87,5}},385}, {{{83,5}},25}, {{{91,5}},6145},
3741 {{{81,5}},7}, {{{89,5}},1537}, {{{85,5}},97}, {{{93,5}},24577},
3742 {{{80,5}},4}, {{{88,5}},769}, {{{84,5}},49}, {{{92,5}},12289},
3743 {{{82,5}},13}, {{{90,5}},3073}, {{{86,5}},193}, {{{192,5}},24577}
3747 int inflate_trees_fixed(uInt *bl, uInt *bd, inflate_huft * *tl, inflate_huft * *td, z_streamp z)
3748 //uInt *bl; /* literal desired/actual bit depth */
3749 //uInt *bd; /* distance desired/actual bit depth */
3750 //inflate_huft * *tl; /* literal/length tree result */
3751 //inflate_huft * *td; /* distance tree result */
3752 //z_streamp z; /* for memory allocation */
3762 /* simplify the use of the inflate_huft type with some defines */
3763 #define exop word.what.Exop
3764 #define bits word.what.Bits
3766 /* macros for bit input with no checking and for returning unused bytes */
3767 #define GRABBITS(j) {while(k<(j)){b|=((uLong)NEXTBYTE)<<k;k+=8;}}
3768 #define UNGRAB {c=z->avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;}
3770 /* Called with number of bytes left to write in window at least 258
3771 (the maximum string length) and number of input bytes available
3772 at least ten. The ten bytes are six bytes for the longest length/
3773 distance pair plus four bytes for overloading the bit buffer. */
3776 int inflate_fast(uInt bl, uInt bd, inflate_huft *tl, inflate_huft *td, inflate_blocks_statef *s, z_streamp z)
3778 inflate_huft *t; /* temporary pointer */
3779 uInt e; /* extra bits or operation */
3780 uLong b; /* bit buffer */
3781 uInt k; /* bits in bit buffer */
3782 Byte *p; /* input data pointer */
3783 uInt n; /* bytes available there */
3784 Byte *q; /* output window write pointer */
3785 uInt m; /* bytes to end of window or read pointer */
3786 uInt ml; /* mask for literal/length tree */
3787 uInt md; /* mask for distance tree */
3788 uInt c; /* bytes to copy */
3789 uInt d; /* distance back to copy from */
3790 Byte *r; /* copy source pointer */
3792 /* load input, output, bit values */
3795 /* initialize masks */
3796 ml = inflate_mask[bl];
3797 md = inflate_mask[bd];
3799 /* do until not enough input or output space for fast loop */
3800 do { /* assume called with m >= 258 && n >= 10 */
3801 /* get literal/length code */
3802 GRABBITS(20) /* max bits for literal/length code */
3803 if ((e = (t = tl + ((uInt)b & ml))->exop) == 0)
3806 Tracevv((t->base >= 0x20 && t->base < 0x7f ?
3807 "inflate: * literal '%c'\n" :
3808 "inflate: * literal 0x%02x\n", t->base));
3809 *q++ = (Byte)t->base;
3817 /* get extra bits for length */
3819 c = t->base + ((uInt)b & inflate_mask[e]);
3821 Tracevv(("inflate: * length %u\n", c));
3823 /* decode distance base of block to copy */
3824 GRABBITS(15); /* max bits for distance code */
3825 e = (t = td + ((uInt)b & md))->exop;
3830 /* get extra bits to add to distance base */
3832 GRABBITS(e) /* get extra bits (up to 13) */
3833 d = t->base + ((uInt)b & inflate_mask[e]);
3835 Tracevv(("inflate: * distance %u\n", d));
3839 if ((uInt)(q - s->window) >= d) /* offset before dest */
3842 *q++ = *r++; c--; /* minimum count is three, */
3843 *q++ = *r++; c--; /* so unroll loop a little */
3845 else /* else offset after destination */
3847 e = d - (uInt)(q - s->window); /* bytes from offset to end */
3848 r = s->end - e; /* pointer to offset */
3849 if (c > e) /* if source crosses, */
3851 c -= e; /* copy to end of window */
3855 r = s->window; /* copy rest from start of window */
3858 do { /* copy all or what's left */
3863 else if ((e & 64) == 0)
3866 e = (t += ((uInt)b & inflate_mask[e]))->exop;
3870 z->msg = (char*)"invalid distance code";
3873 return Z_DATA_ERROR;
3881 if ((e = (t += ((uInt)b & inflate_mask[e]))->exop) == 0)
3884 Tracevv((t->base >= 0x20 && t->base < 0x7f ?
3885 "inflate: * literal '%c'\n" :
3886 "inflate: * literal 0x%02x\n", t->base));
3887 *q++ = (Byte)t->base;
3894 Tracevv(("inflate: * end of block\n"));
3897 return Z_STREAM_END;
3901 z->msg = (char*)"invalid literal/length code";
3904 return Z_DATA_ERROR;
3907 } while (m >= 258 && n >= 10);
3909 /* not enough input or output--restore pointers and return */
3916 /* infcodes.c -- process literals and length/distance pairs
3917 * Copyright (C) 1995-1998 Mark Adler
3918 * For conditions of distribution and use, see copyright notice in zlib.h
3921 /* simplify the use of the inflate_huft type with some defines */
3922 #define exop word.what.Exop
3923 #define bits word.what.Bits
3925 typedef enum { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
3926 START, /* x: set up for LEN */
3927 LEN, /* i: get length/literal/eob next */
3928 LENEXT, /* i: getting length extra (have base) */
3929 DIST, /* i: get distance next */
3930 DISTEXT, /* i: getting distance extra */
3931 COPY, /* o: copying bytes in window, waiting for space */
3932 LIT, /* o: got literal, waiting for output space */
3933 WASH, /* o: got eob, possibly still output waiting */
3934 END, /* x: got eob and all data flushed */
3935 BADCODE} /* x: got error */
3938 /* inflate codes private state */
3939 struct inflate_codes_state {
3942 inflate_codes_mode mode; /* current inflate_codes mode */
3944 /* mode dependent information */
3948 inflate_huft *tree; /* pointer into tree */
3949 uInt need; /* bits needed */
3950 } code; /* if LEN or DIST, where in tree */
3951 uInt lit; /* if LIT, literal */
3953 uInt get; /* bits to get for extra */
3954 uInt dist; /* distance back to copy from */
3955 } copy; /* if EXT or COPY, where and how much */
3956 } sub; /* submode */
3958 /* mode independent information */
3959 Byte lbits; /* ltree bits decoded per branch */
3960 Byte dbits; /* dtree bits decoder per branch */
3961 inflate_huft *ltree; /* literal/length/eob tree */
3962 inflate_huft *dtree; /* distance tree */
3967 inflate_codes_statef *inflate_codes_new(uInt bl, uInt bd, inflate_huft *tl, inflate_huft *td, z_streamp z)
3969 inflate_codes_statef *c;
3971 if ((c = (inflate_codes_statef *)
3972 ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL)
3975 c->lbits = (Byte)bl;
3976 c->dbits = (Byte)bd;
3979 Tracev(("inflate: codes new\n"));
3986 int inflate_codes(inflate_blocks_statef *s, z_streamp z, int r)
3988 uInt j; /* temporary storage */
3989 inflate_huft *t; /* temporary pointer */
3990 uInt e; /* extra bits or operation */
3991 uLong b; /* bit buffer */
3992 uInt k; /* bits in bit buffer */
3993 Byte *p; /* input data pointer */
3994 uInt n; /* bytes available there */
3995 Byte *q; /* output window write pointer */
3996 uInt m; /* bytes to end of window or read pointer */
3997 Byte *f; /* pointer to copy strings from */
3998 inflate_codes_statef *c = s->sub.decode.codes; /* codes state */
4000 /* copy input/output information to locals (UPDATE macro restores) */
4003 /* process input and output based on current state */
4004 while (1) switch (c->mode)
4005 { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
4006 case START: /* x: set up for LEN */
4008 if (m >= 258 && n >= 10)
4011 r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
4015 c->mode = r == Z_STREAM_END ? WASH : BADCODE;
4020 c->sub.code.need = c->lbits;
4021 c->sub.code.tree = c->ltree;
4023 case LEN: /* i: get length/literal/eob next */
4024 j = c->sub.code.need;
4026 t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
4028 e = (uInt)(t->exop);
4029 if (e == 0) /* literal */
4031 c->sub.lit = t->base;
4032 Tracevv((t->base >= 0x20 && t->base < 0x7f ?
4033 "inflate: literal '%c'\n" :
4034 "inflate: literal 0x%02x\n", t->base));
4038 if (e & 16) /* length */
4040 c->sub.copy.get = e & 15;
4045 if ((e & 64) == 0) /* next table */
4047 c->sub.code.need = e;
4048 c->sub.code.tree = t + t->base;
4051 if (e & 32) /* end of block */
4053 Tracevv(("inflate: end of block\n"));
4057 c->mode = BADCODE; /* invalid code */
4058 z->msg = (char*)"invalid literal/length code";
4061 case LENEXT: /* i: getting length extra (have base) */
4062 j = c->sub.copy.get;
4064 c->len += (uInt)b & inflate_mask[j];
4066 c->sub.code.need = c->dbits;
4067 c->sub.code.tree = c->dtree;
4068 Tracevv(("inflate: length %u\n", c->len));
4070 case DIST: /* i: get distance next */
4071 j = c->sub.code.need;
4073 t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
4075 e = (uInt)(t->exop);
4076 if (e & 16) /* distance */
4078 c->sub.copy.get = e & 15;
4079 c->sub.copy.dist = t->base;
4083 if ((e & 64) == 0) /* next table */
4085 c->sub.code.need = e;
4086 c->sub.code.tree = t + t->base;
4089 c->mode = BADCODE; /* invalid code */
4090 z->msg = (char*)"invalid distance code";
4093 case DISTEXT: /* i: getting distance extra */
4094 j = c->sub.copy.get;
4096 c->sub.copy.dist += (uInt)b & inflate_mask[j];
4098 Tracevv(("inflate: distance %u\n", c->sub.copy.dist));
4100 case COPY: /* o: copying bytes in window, waiting for space */
4101 #ifndef __TURBOC__ /* Turbo C bug for following expression */
4102 f = (uInt)(q - s->window) < c->sub.copy.dist ?
4103 s->end - (c->sub.copy.dist - (q - s->window)) :
4104 q - c->sub.copy.dist;
4106 f = q - c->sub.copy.dist;
4107 if ((uInt)(q - s->window) < c->sub.copy.dist)
4108 f = s->end - (c->sub.copy.dist - (uInt)(q - s->window));
4120 case LIT: /* o: got literal, waiting for output space */
4125 case WASH: /* o: got eob, possibly more output */
4126 if (k > 7) /* return unused byte, if any */
4128 Assert(k < 16, "inflate_codes grabbed too many bytes")
4131 p--; /* can always return one */
4134 if (s->read != s->write)
4140 case BADCODE: /* x: got error */
4147 #ifdef NEED_DUMMY_RETURN
4148 return Z_STREAM_ERROR; /* Some dumb compilers complain without this */
4154 void inflate_codes_free(inflate_codes_statef *c, z_streamp z)
4157 Tracev(("inflate: codes free\n"));
4161 /* adler32.c -- compute the Adler-32 checksum of a data stream
4162 * Copyright (C) 1995-1998 Mark Adler
4163 * For conditions of distribution and use, see copyright notice in zlib.h
4166 #define BASE 65521L /* largest prime smaller than 65536 */
4168 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
4175 #define DO1(buf,i) {s1 += buf[i]; s2 += s1;}
4176 #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
4177 #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
4178 #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
4179 #define DO16(buf) DO8(buf,0); DO8(buf,8);
4181 /* ========================================================================= */
4183 uLong adler32(uLong adler, const Byte *buf, uInt len)
4185 unsigned long s1 = adler & 0xffff;
4186 unsigned long s2 = (adler >> 16) & 0xffff;
4189 if (buf == Z_NULL) return 1L;
4192 k = len < NMAX ? len : NMAX;
4206 return (s2 << 16) | s1;
4211 /* infblock.h -- header to use infblock.c
4212 * Copyright (C) 1995-1998 Mark Adler
4213 * For conditions of distribution and use, see copyright notice in zlib.h
4216 /* WARNING: this file should *not* be used by applications. It is
4217 part of the implementation of the compression library and is
4218 subject to change. Applications should only use zlib.h.
4221 extern inflate_blocks_statef * inflate_blocks_new OF((
4223 check_func c, /* check function */
4224 uInt w)); /* window size */
4226 extern int inflate_blocks OF((
4227 inflate_blocks_statef *,
4229 int)); /* initial return code */
4231 extern void inflate_blocks_reset OF((
4232 inflate_blocks_statef *,
4234 uLong *)); /* check value on output */
4236 extern int inflate_blocks_free OF((
4237 inflate_blocks_statef *,
4240 extern void inflate_set_dictionary OF((
4241 inflate_blocks_statef *s,
4242 const Byte *d, /* dictionary */
4243 uInt n)); /* dictionary length */
4245 extern int inflate_blocks_sync_point OF((
4246 inflate_blocks_statef *s));
4249 imMETHOD, /* waiting for method byte */
4250 imFLAG, /* waiting for flag byte */
4251 imDICT4, /* four dictionary check bytes to go */
4252 imDICT3, /* three dictionary check bytes to go */
4253 imDICT2, /* two dictionary check bytes to go */
4254 imDICT1, /* one dictionary check byte to go */
4255 imDICT0, /* waiting for inflateSetDictionary */
4256 imBLOCKS, /* decompressing blocks */
4257 imCHECK4, /* four check bytes to go */
4258 imCHECK3, /* three check bytes to go */
4259 imCHECK2, /* two check bytes to go */
4260 imCHECK1, /* one check byte to go */
4261 imDONE, /* finished check, done */
4262 imBAD} /* got an error--stay here */
4265 /* inflate private state */
4266 struct internal_state {
4269 inflate_mode mode; /* current inflate mode */
4271 /* mode dependent information */
4273 uInt method; /* if FLAGS, method byte */
4275 uLong was; /* computed check value */
4276 uLong need; /* stream check value */
4277 } check; /* if CHECK, check values to compare */
4278 uInt marker; /* if BAD, inflateSync's marker bytes count */
4279 } sub; /* submode */
4281 /* mode independent information */
4282 int nowrap; /* flag for no wrapper */
4283 uInt wbits; /* log2(window size) (8..15, defaults to 15) */
4284 inflate_blocks_statef
4285 *blocks; /* current inflate_blocks state */
4291 int inflateReset(z_streamp z)
4293 if (z == Z_NULL || z->state == Z_NULL)
4294 return Z_STREAM_ERROR;
4295 z->total_in = z->total_out = 0;
4297 z->state->mode = z->state->nowrap ? imBLOCKS : imMETHOD;
4298 inflate_blocks_reset(z->state->blocks, z, Z_NULL);
4299 Tracev(("inflate: reset\n"));
4305 int inflateEnd(z_streamp z)
4307 if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)
4308 return Z_STREAM_ERROR;
4309 if (z->state->blocks != Z_NULL)
4310 inflate_blocks_free(z->state->blocks, z);
4313 Tracev(("inflate: end\n"));
4319 int inflateInit2_(z_streamp z, int w, const char *version, int stream_size)
4321 if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
4322 stream_size != sizeof(z_stream))
4323 return Z_VERSION_ERROR;
4325 /* initialize state */
4327 return Z_STREAM_ERROR;
4329 if (z->zalloc == Z_NULL)
4331 z->zalloc = (void *(*)(void *, unsigned, unsigned))zcalloc;
4332 z->opaque = (voidp)0;
4334 if (z->zfree == Z_NULL) z->zfree = (void (*)(void *, void *))zcfree;
4335 if ((z->state = (struct internal_state *)
4336 ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL)
4338 z->state->blocks = Z_NULL;
4340 /* handle undocumented nowrap option (no zlib header or check) */
4341 z->state->nowrap = 0;
4345 z->state->nowrap = 1;
4348 /* set window size */
4349 if (w < 8 || w > 15)
4352 return Z_STREAM_ERROR;
4354 z->state->wbits = (uInt)w;
4356 /* create inflate_blocks state */
4357 if ((z->state->blocks =
4358 inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w))
4364 Tracev(("inflate: allocated\n"));
4373 int inflateInit_(z_streamp z, const char *version, int stream_size)
4375 return inflateInit2_(z, DEF_WBITS, version, stream_size);
4379 #define iNEEDBYTE {if(z->avail_in==0)return r;r=f;}
4380 #define iNEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++)
4383 int inflate(z_streamp z, int f)
4388 if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL)
4389 return Z_STREAM_ERROR;
4390 f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
4392 while (1) switch (z->state->mode)
4396 if (((z->state->sub.method = iNEXTBYTE) & 0xf) != Z_DEFLATED)
4398 z->state->mode = imBAD;
4399 z->msg = (char*)"unknown compression method";
4400 z->state->sub.marker = 5; /* can't try inflateSync */
4403 if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
4405 z->state->mode = imBAD;
4406 z->msg = (char*)"invalid window size";
4407 z->state->sub.marker = 5; /* can't try inflateSync */
4410 z->state->mode = imFLAG;
4414 if (((z->state->sub.method << 8) + b) % 31)
4416 z->state->mode = imBAD;
4417 z->msg = (char*)"incorrect header check";
4418 z->state->sub.marker = 5; /* can't try inflateSync */
4421 Tracev(("inflate: zlib header ok\n"));
4422 if (!(b & PRESET_DICT))
4424 z->state->mode = imBLOCKS;
4427 z->state->mode = imDICT4;
4430 z->state->sub.check.need = (uLong)iNEXTBYTE << 24;
4431 z->state->mode = imDICT3;
4434 z->state->sub.check.need += (uLong)iNEXTBYTE << 16;
4435 z->state->mode = imDICT2;
4438 z->state->sub.check.need += (uLong)iNEXTBYTE << 8;
4439 z->state->mode = imDICT1;
4442 z->state->sub.check.need += (uLong)iNEXTBYTE;
4443 z->adler = z->state->sub.check.need;
4444 z->state->mode = imDICT0;
4447 z->state->mode = imBAD;
4448 z->msg = (char*)"need dictionary";
4449 z->state->sub.marker = 0; /* can try inflateSync */
4450 return Z_STREAM_ERROR;
4452 r = inflate_blocks(z->state->blocks, z, r);
4453 if (r == Z_DATA_ERROR)
4455 z->state->mode = imBAD;
4456 z->state->sub.marker = 0; /* can try inflateSync */
4461 if (r != Z_STREAM_END)
4464 inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was);
4465 if (z->state->nowrap)
4467 z->state->mode = imDONE;
4470 z->state->mode = imCHECK4;
4473 z->state->sub.check.need = (uLong)iNEXTBYTE << 24;
4474 z->state->mode = imCHECK3;
4477 z->state->sub.check.need += (uLong)iNEXTBYTE << 16;
4478 z->state->mode = imCHECK2;
4481 z->state->sub.check.need += (uLong)iNEXTBYTE << 8;
4482 z->state->mode = imCHECK1;
4485 z->state->sub.check.need += (uLong)iNEXTBYTE;
4487 if (z->state->sub.check.was != z->state->sub.check.need)
4489 z->state->mode = imBAD;
4490 z->msg = (char*)"incorrect data check";
4491 z->state->sub.marker = 5; /* can't try inflateSync */
4494 Tracev(("inflate: zlib check ok\n"));
4495 z->state->mode = imDONE;
4497 return Z_STREAM_END;
4499 return Z_DATA_ERROR;
4501 return Z_STREAM_ERROR;
4503 #ifdef NEED_DUMMY_RETURN
4504 return Z_STREAM_ERROR; /* Some dumb compilers complain without this */
4510 int inflateSetDictionary(z_streamp z, const Byte *dictionary, uInt dictLength)
4512 uInt length = dictLength;
4514 if (z == Z_NULL || z->state == Z_NULL || z->state->mode != imDICT0)
4515 return Z_STREAM_ERROR;
4517 if (adler32(1L, dictionary, dictLength) != z->adler) return Z_DATA_ERROR;
4520 if (length >= ((uInt)1<<z->state->wbits))
4522 length = (1<<z->state->wbits)-1;
4523 dictionary += dictLength - length;
4525 inflate_set_dictionary(z->state->blocks, dictionary, length);
4526 z->state->mode = imBLOCKS;
4532 int inflateSync(z_streamp z)
4534 uInt n; /* number of bytes to look at */
4535 Byte *p; /* pointer to bytes */
4536 uInt m; /* number of marker bytes found in a row */
4537 uLong r, w; /* temporaries to save total_in and total_out */
4540 if (z == Z_NULL || z->state == Z_NULL)
4541 return Z_STREAM_ERROR;
4542 if (z->state->mode != imBAD)
4544 z->state->mode = imBAD;
4545 z->state->sub.marker = 0;
4547 if ((n = z->avail_in) == 0)
4550 m = z->state->sub.marker;
4555 static const Byte mark[4] = {0, 0, 0xff, 0xff};
4566 z->total_in += p - z->next_in;
4569 z->state->sub.marker = m;
4571 /* return no joy or set up to restart on a new block */
4573 return Z_DATA_ERROR;
4574 r = z->total_in; w = z->total_out;
4576 z->total_in = r; z->total_out = w;
4577 z->state->mode = imBLOCKS;
4582 /* Returns true if inflate is currently at the end of a block generated
4583 * by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
4584 * implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
4585 * but removes the length bytes of the resulting empty stored block. When
4586 * decompressing, PPP checks that at the end of input packet, inflate is
4587 * waiting for these length bytes.
4590 int inflateSyncPoint(z_streamp z)
4592 if (z == Z_NULL || z->state == Z_NULL || z->state->blocks == Z_NULL)
4593 return Z_STREAM_ERROR;
4594 return inflate_blocks_sync_point(z->state->blocks);
4599 voidp zcalloc (voidp opaque, unsigned items, unsigned size)
4601 if (opaque) items += size - size; /* make compiler happy */
4602 return (voidp)safe_malloc(items*size);
4605 void zcfree (voidp opaque, voidp ptr)
4608 if (opaque) return; /* make compiler happy */