1 /*****************************************************************************
4 * desc: IO on .zip files using portions of zlib
7 *****************************************************************************/
12 #include "unzip-vfspk3.h"
14 typedef unsigned char byte;
16 /* unzip.h -- IO for uncompress .zip files using zlib
17 Version 0.15 beta, Mar 19th, 1998,
19 Copyright (C) 1998 Gilles Vollant
21 This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
22 WinZip, InfoZip tools and compatible.
23 Encryption and multi volume ZipFile (span) are not supported.
24 Old compressions used by old PKZip 1.x are not supported
26 THIS IS AN ALPHA VERSION. AT THIS STAGE OF DEVELOPPEMENT, SOMES API OR STRUCTURE
27 CAN CHANGE IN FUTURE VERSION !!
28 I WAIT FEEDBACK at mail info@winimage.com
29 Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
31 Condition of use and distribution are the same than zlib :
33 This software is provided 'as-is', without any express or implied
34 warranty. In no event will the authors be held liable for any damages
35 arising from the use of this software.
37 Permission is granted to anyone to use this software for any purpose,
38 including commercial applications, and to alter it and redistribute it
39 freely, subject to the following restrictions:
41 1. The origin of this software must not be misrepresented; you must not
42 claim that you wrote the original software. If you use this software
43 in a product, an acknowledgment in the product documentation would be
44 appreciated but is not required.
45 2. Altered source versions must be plainly marked as such, and must not be
46 misrepresented as being the original software.
47 3. This notice may not be removed or altered from any source distribution.
51 /* for more info about .ZIP format, see
52 ftp://ftp.cdrom.com/pub/infozip/doc/appnote-970311-iz.zip
53 PkWare has also a specification at :
54 ftp://ftp.pkware.com/probdesc.zip */
56 /* zlib.h -- interface of the 'zlib' general purpose compression library
57 version 1.1.3, July 9th, 1998
59 Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
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.
77 Jean-loup Gailly Mark Adler
78 jloup@gzip.org madler@alumni.caltech.edu
81 The data format used by the zlib library is described by RFCs (Request for
82 Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
83 (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
86 /* zconf.h -- configuration of the zlib compression library
87 * Copyright (C) 1995-1998 Jean-loup Gailly.
88 * For conditions of distribution and use, see copyright notice in zlib.h
95 /* Maximum value for memLevel in deflateInit2 */
98 # define MAX_MEM_LEVEL 8
100 # define MAX_MEM_LEVEL 9
104 /* Maximum value for windowBits in deflateInit2 and inflateInit2.
105 * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
106 * created by gzip. (Files created by minigzip can still be extracted by
110 # define MAX_WBITS 15 /* 32K LZ77 window */
113 /* The memory requirements for deflate are (in bytes):
114 (1 << (windowBits+2)) + (1 << (memLevel+9))
115 that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
116 plus a few kilobytes for small objects. For example, if you want to reduce
117 the default memory requirements from 256K to 128K, compile with
118 make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
119 Of course this will generally degrade compression (there's no free lunch).
121 The memory requirements for inflate are (in bytes) 1 << windowBits
122 that is, 32K for windowBits=15 (default value) plus a few kilobytes
126 /* Type declarations */
128 #ifndef OF /* function prototypes */
129 #define OF( args ) args
132 typedef unsigned char Byte; /* 8 bits */
133 typedef unsigned int uInt; /* 16 bits or more */
134 typedef unsigned long uLong; /* 32 bits or more */
138 # define SEEK_SET 0 /* Seek from beginning of file. */
139 # define SEEK_CUR 1 /* Seek from current position. */
140 # define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
143 #endif /* _ZCONF_H */
145 #define ZLIB_VERSION "1.1.3"
148 The 'zlib' compression library provides in-memory compression and
149 decompression functions, including integrity checks of the uncompressed
150 data. This version of the library supports only one compression method
151 (deflation) but other algorithms will be added later and will have the same
154 Compression can be done in a single step if the buffers are large
155 enough (for example if an input file is mmap'ed), or can be done by
156 repeated calls of the compression function. In the latter case, the
157 application must provide more input and/or consume the output
158 (providing more output space) before each call.
160 The library also supports reading and writing files in gzip (.gz) format
161 with an interface similar to that of stdio.
163 The library does not install any signal handler. The decoder checks
164 the consistency of the compressed data, so the library should never
165 crash even in case of corrupted input.
169 The application must update next_in and avail_in when avail_in has
170 dropped to zero. It must update next_out and avail_out when avail_out
171 has dropped to zero. The application must initialize zalloc, zfree and
172 opaque before calling the init function. All other fields are set by the
173 compression library and must not be updated by the application.
175 The opaque value provided by the application will be passed as the first
176 parameter for calls of zalloc and zfree. This can be useful for custom
177 memory management. The compression library attaches no meaning to the
180 zalloc must return Z_NULL if there is not enough memory for the object.
181 If zlib is used in a multi-threaded application, zalloc and zfree must be
184 On 16-bit systems, the functions zalloc and zfree must be able to allocate
185 exactly 65536 bytes, but will not be required to allocate more than this
186 if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
187 pointers returned by zalloc for objects of exactly 65536 bytes *must*
188 have their offset normalized to zero. The default allocation function
189 provided by this library ensures this (see zutil.c). To reduce memory
190 requirements and avoid any allocation of 64K objects, at the expense of
191 compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
193 The fields total_in and total_out can be used for statistics or
194 progress reports. After compression, total_in holds the total size of
195 the uncompressed data and may be saved for use in the decompressor
196 (particularly if the decompressor wants to decompress everything in
203 #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
204 #define Z_SYNC_FLUSH 2
205 #define Z_FULL_FLUSH 3
207 /* Allowed flush values; see deflate() below for details */
210 #define Z_STREAM_END 1
211 #define Z_NEED_DICT 2
212 #define Z_ERRNO ( -1 )
213 #define Z_STREAM_ERROR ( -2 )
214 #define Z_DATA_ERROR ( -3 )
215 #define Z_MEM_ERROR ( -4 )
216 #define Z_BUF_ERROR ( -5 )
217 #define Z_VERSION_ERROR ( -6 )
218 /* Return codes for the compression/decompression functions. Negative
219 * values are errors, positive values are used for special but normal events.
222 #define Z_NO_COMPRESSION 0
223 #define Z_BEST_SPEED 1
224 #define Z_BEST_COMPRESSION 9
225 #define Z_DEFAULT_COMPRESSION ( -1 )
226 /* compression levels */
229 #define Z_HUFFMAN_ONLY 2
230 #define Z_DEFAULT_STRATEGY 0
231 /* compression strategy; see deflateInit2() below for details */
236 /* Possible values of the data_type field */
239 /* The deflate compression method (the only one supported in this version) */
241 #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
243 #define zlib_version zlibVersion()
244 /* for compatibility with versions < 1.0.2 */
246 /* basic functions */
248 const char * zlibVersion OF( (void) );
249 /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
250 If the first character differs, the library code actually used is
251 not compatible with the zlib.h header file used by the application.
252 This check is automatically made by deflateInit and inflateInit.
256 int deflateInit OF((z_streamp strm, int level));
258 Initializes the internal stream state for compression. The fields
259 zalloc, zfree and opaque must be initialized before by the caller.
260 If zalloc and zfree are set to Z_NULL, deflateInit updates them to
261 use default allocation functions.
263 The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
264 1 gives best speed, 9 gives best compression, 0 gives no compression at
265 all (the input data is simply copied a block at a time).
266 Z_DEFAULT_COMPRESSION requests a default compromise between speed and
267 compression (currently equivalent to level 6).
269 deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
270 enough memory, Z_STREAM_ERROR if level is not a valid compression level,
271 Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
272 with the version assumed by the caller (ZLIB_VERSION).
273 msg is set to null if there is no error message. deflateInit does not
274 perform any compression: this will be done by deflate().
278 int deflate OF( ( z_streamp strm, int flush ) );
280 deflate compresses as much data as possible, and stops when the input
281 buffer becomes empty or the output buffer becomes full. It may introduce some
282 output latency (reading input without producing any output) except when
285 The detailed semantics are as follows. deflate performs one or both of the
288 - Compress more input starting at next_in and update next_in and avail_in
289 accordingly. If not all input can be processed (because there is not
290 enough room in the output buffer), next_in and avail_in are updated and
291 processing will resume at this point for the next call of deflate().
293 - Provide more output starting at next_out and update next_out and avail_out
294 accordingly. This action is forced if the parameter flush is non zero.
295 Forcing flush frequently degrades the compression ratio, so this parameter
296 should be set only when necessary (in interactive applications).
297 Some output may be provided even if flush is not set.
299 Before the call of deflate(), the application should ensure that at least
300 one of the actions is possible, by providing more input and/or consuming
301 more output, and updating avail_in or avail_out accordingly; avail_out
302 should never be zero before the call. The application can consume the
303 compressed output when it wants, for example when the output buffer is full
304 (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
305 and with zero avail_out, it must be called again after making room in the
306 output buffer because there might be more output pending.
308 If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
309 flushed to the output buffer and the output is aligned on a byte boundary, so
310 that the decompressor can get all input data available so far. (In particular
311 avail_in is zero after the call if enough output space has been provided
312 before the call.) Flushing may degrade compression for some compression
313 algorithms and so it should be used only when necessary.
315 If flush is set to Z_FULL_FLUSH, all output is flushed as with
316 Z_SYNC_FLUSH, and the compression state is reset so that decompression can
317 restart from this point if previous compressed data has been damaged or if
318 random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
321 If deflate returns with avail_out == 0, this function must be called again
322 with the same value of the flush parameter and more output space (updated
323 avail_out), until the flush is complete (deflate returns with non-zero
326 If the parameter flush is set to Z_FINISH, pending input is processed,
327 pending output is flushed and deflate returns with Z_STREAM_END if there
328 was enough output space; if deflate returns with Z_OK, this function must be
329 called again with Z_FINISH and more output space (updated avail_out) but no
330 more input data, until it returns with Z_STREAM_END or an error. After
331 deflate has returned Z_STREAM_END, the only possible operations on the
332 stream are deflateReset or deflateEnd.
334 Z_FINISH can be used immediately after deflateInit if all the compression
335 is to be done in a single step. In this case, avail_out must be at least
336 0.1% larger than avail_in plus 12 bytes. If deflate does not return
337 Z_STREAM_END, then it must be called again as described above.
339 deflate() sets strm->adler to the adler32 checksum of all input read
340 so (that is, total_in bytes).
342 deflate() may update data_type if it can make a good guess about
343 the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
344 binary. This field is only for information purposes and does not affect
345 the compression algorithm in any manner.
347 deflate() returns Z_OK if some progress has been made (more input
348 processed or more output produced), Z_STREAM_END if all input has been
349 consumed and all output has been produced (only when flush is set to
350 Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
351 if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
352 (for example avail_in or avail_out was zero).
356 int deflateEnd OF( (z_streamp strm) );
358 All dynamically allocated data structures for this stream are freed.
359 This function discards any unprocessed input and does not flush any
362 deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
363 stream state was inconsistent, Z_DATA_ERROR if the stream was freed
364 prematurely (some input or output was discarded). In the error case,
365 msg may be set but then points to a static string (which must not be
371 int inflateInit OF((z_streamp strm));
373 Initializes the internal stream state for decompression. The fields
374 next_in, avail_in, zalloc, zfree and opaque must be initialized before by
375 the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
376 value depends on the compression method), inflateInit determines the
377 compression method from the zlib header and allocates all data structures
378 accordingly; otherwise the allocation will be deferred to the first call of
379 inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
380 use default allocation functions.
382 inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
383 memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
384 version assumed by the caller. msg is set to null if there is no error
385 message. inflateInit does not perform any decompression apart from reading
386 the zlib header if present: this will be done by inflate(). (So next_in and
387 avail_in may be modified, but next_out and avail_out are unchanged.)
391 int inflate OF( ( z_streamp strm, int flush ) );
393 inflate decompresses as much data as possible, and stops when the input
394 buffer becomes empty or the output buffer becomes full. It may some
395 introduce some output latency (reading input without producing any output)
396 except when forced to flush.
398 The detailed semantics are as follows. inflate performs one or both of the
401 - Decompress more input starting at next_in and update next_in and avail_in
402 accordingly. If not all input can be processed (because there is not
403 enough room in the output buffer), next_in is updated and processing
404 will resume at this point for the next call of inflate().
406 - Provide more output starting at next_out and update next_out and avail_out
407 accordingly. inflate() provides as much output as possible, until there
408 is no more input data or no more space in the output buffer (see below
409 about the flush parameter).
411 Before the call of inflate(), the application should ensure that at least
412 one of the actions is possible, by providing more input and/or consuming
413 more output, and updating the next_* and avail_* values accordingly.
414 The application can consume the uncompressed output when it wants, for
415 example when the output buffer is full (avail_out == 0), or after each
416 call of inflate(). If inflate returns Z_OK and with zero avail_out, it
417 must be called again after making room in the output buffer because there
418 might be more output pending.
420 If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
421 output as possible to the output buffer. The flushing behavior of inflate is
422 not specified for values of the flush parameter other than Z_SYNC_FLUSH
423 and Z_FINISH, but the current implementation actually flushes as much output
426 inflate() should normally be called until it returns Z_STREAM_END or an
427 error. However if all decompression is to be performed in a single step
428 (a single call of inflate), the parameter flush should be set to
429 Z_FINISH. In this case all pending input is processed and all pending
430 output is flushed; avail_out must be large enough to hold all the
431 uncompressed data. (The size of the uncompressed data may have been saved
432 by the compressor for this purpose.) The next operation on this stream must
433 be inflateEnd to deallocate the decompression state. The use of Z_FINISH
434 is never required, but can be used to inform inflate that a faster routine
435 may be used for the single inflate() call.
437 If a preset dictionary is needed at this point (see inflateSetDictionary
438 below), inflate sets strm-adler to the adler32 checksum of the
439 dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise
440 it sets strm->adler to the adler32 checksum of all output produced
441 so (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
442 an error code as described below. At the end of the stream, inflate()
443 checks that its computed adler32 checksum is equal to that saved by the
444 compressor and returns Z_STREAM_END only if the checksum is correct.
446 inflate() returns Z_OK if some progress has been made (more input processed
447 or more output produced), Z_STREAM_END if the end of the compressed data has
448 been reached and all uncompressed output has been produced, Z_NEED_DICT if a
449 preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
450 corrupted (input stream not conforming to the zlib format or incorrect
451 adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
452 (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
453 enough memory, Z_BUF_ERROR if no progress is possible or if there was not
454 enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
455 case, the application may then call inflateSync to look for a good
460 int inflateEnd OF( (z_streamp strm) );
462 All dynamically allocated data structures for this stream are freed.
463 This function discards any unprocessed input and does not flush any
466 inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
467 was inconsistent. In the error case, msg may be set but then points to a
468 static string (which must not be deallocated).
471 /* Advanced functions */
474 The following functions are needed only in some special applications.
478 int deflateInit2 OF((z_streamp strm,
485 This is another version of deflateInit with more compression options. The
486 fields next_in, zalloc, zfree and opaque must be initialized before by
489 The method parameter is the compression method. It must be Z_DEFLATED in
490 this version of the library.
492 The windowBits parameter is the base two logarithm of the window size
493 (the size of the history buffer). It should be in the range 8..15 for this
494 version of the library. Larger values of this parameter result in better
495 compression at the expense of memory usage. The default value is 15 if
496 deflateInit is used instead.
498 The memLevel parameter specifies how much memory should be allocated
499 for the internal compression state. memLevel=1 uses minimum memory but
500 is slow and reduces compression ratio; memLevel=9 uses maximum memory
501 for optimal speed. The default value is 8. See zconf.h for total memory
502 usage as a function of windowBits and memLevel.
504 The strategy parameter is used to tune the compression algorithm. Use the
505 value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
506 filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
507 string match). Filtered data consists mostly of small values with a
508 somewhat random distribution. In this case, the compression algorithm is
509 tuned to compress them better. The effect of Z_FILTERED is to force more
510 Huffman coding and less string matching; it is somewhat intermediate
511 between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
512 the compression ratio but not the correctness of the compressed output even
513 if it is not set appropriately.
515 deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
516 memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
517 method). msg is set to null if there is no error message. deflateInit2 does
518 not perform any compression: this will be done by deflate().
521 int deflateSetDictionary OF( ( z_streamp strm,
522 const Byte * dictionary,
525 Initializes the compression dictionary from the given byte sequence
526 without producing any compressed output. This function must be called
527 immediately after deflateInit, deflateInit2 or deflateReset, before any
528 call of deflate. The compressor and decompressor must use exactly the same
529 dictionary (see inflateSetDictionary).
531 The dictionary should consist of strings (byte sequences) that are likely
532 to be encountered later in the data to be compressed, with the most commonly
533 used strings preferably put towards the end of the dictionary. Using a
534 dictionary is most useful when the data to be compressed is short and can be
535 predicted with good accuracy; the data can then be compressed better than
536 with the default empty dictionary.
538 Depending on the size of the compression data structures selected by
539 deflateInit or deflateInit2, a part of the dictionary may in effect be
540 discarded, for example if the dictionary is larger than the window size in
541 deflate or deflate2. Thus the strings most likely to be useful should be
542 put at the end of the dictionary, not at the front.
544 Upon return of this function, strm->adler is set to the Adler32 value
545 of the dictionary; the decompressor may later use this value to determine
546 which dictionary has been used by the compressor. (The Adler32 value
547 applies to the whole dictionary even if only a subset of the dictionary is
548 actually used by the compressor.)
550 deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
551 parameter is invalid (such as NULL dictionary) or the stream state is
552 inconsistent (for example if deflate has already been called for this stream
553 or if the compression method is bsort). deflateSetDictionary does not
554 perform any compression: this will be done by deflate().
557 int deflateCopy OF( ( z_streamp dest,
558 z_streamp source ) );
560 Sets the destination stream as a complete copy of the source stream.
562 This function can be useful when several compression strategies will be
563 tried, for example when there are several ways of pre-processing the input
564 data with a filter. The streams that will be discarded should then be freed
565 by calling deflateEnd. Note that deflateCopy duplicates the internal
566 compression state which can be quite large, so this strategy is slow and
567 can consume lots of memory.
569 deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
570 enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
571 (such as zalloc being NULL). msg is left unchanged in both source and
575 int deflateReset OF( (z_streamp strm) );
577 This function is equivalent to deflateEnd followed by deflateInit,
578 but does not free and reallocate all the internal compression state.
579 The stream will keep the same compression level and any other attributes
580 that may have been set by deflateInit2.
582 deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
583 stream state was inconsistent (such as zalloc or state being NULL).
586 int deflateParams OF( ( z_streamp strm,
590 Dynamically update the compression level and compression strategy. The
591 interpretation of level and strategy is as in deflateInit2. This can be
592 used to switch between compression and straight copy of the input data, or
593 to switch to a different kind of input data requiring a different
594 strategy. If the compression level is changed, the input available so far
595 is compressed with the old level (and may be flushed); the new level will
596 take effect only at the next call of deflate().
598 Before the call of deflateParams, the stream state must be set as for
599 a call of deflate(), since the currently available input may have to
600 be compressed and flushed. In particular, strm->avail_out must be non-zero.
602 deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
603 stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
604 if strm->avail_out was zero.
608 int inflateInit2 OF((z_streamp strm,
611 This is another version of inflateInit with an extra parameter. The
612 fields next_in, avail_in, zalloc, zfree and opaque must be initialized
613 before by the caller.
615 The windowBits parameter is the base two logarithm of the maximum window
616 size (the size of the history buffer). It should be in the range 8..15 for
617 this version of the library. The default value is 15 if inflateInit is used
618 instead. If a compressed stream with a larger window size is given as
619 input, inflate() will return with the error code Z_DATA_ERROR instead of
620 trying to allocate a larger window.
622 inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
623 memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
624 memLevel). msg is set to null if there is no error message. inflateInit2
625 does not perform any decompression apart from reading the zlib header if
626 present: this will be done by inflate(). (So next_in and avail_in may be
627 modified, but next_out and avail_out are unchanged.)
630 int inflateSetDictionary OF( ( z_streamp strm,
631 const Byte * dictionary,
634 Initializes the decompression dictionary from the given uncompressed byte
635 sequence. This function must be called immediately after a call of inflate
636 if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
637 can be determined from the Adler32 value returned by this call of
638 inflate. The compressor and decompressor must use exactly the same
639 dictionary (see deflateSetDictionary).
641 inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
642 parameter is invalid (such as NULL dictionary) or the stream state is
643 inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
644 expected one (incorrect Adler32 value). inflateSetDictionary does not
645 perform any decompression: this will be done by subsequent calls of
649 int inflateSync OF( (z_streamp strm) );
651 Skips invalid compressed data until a full flush point (see above the
652 description of deflate with Z_FULL_FLUSH) can be found, or until all
653 available input is skipped. No output is provided.
655 inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
656 if no more input was provided, Z_DATA_ERROR if no flush point has been found,
657 or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
658 case, the application may save the current current value of total_in which
659 indicates where valid compressed data was found. In the error case, the
660 application may repeatedly call inflateSync, providing more input each time,
661 until success or end of the input data.
664 int inflateReset OF( (z_streamp strm) );
666 This function is equivalent to inflateEnd followed by inflateInit,
667 but does not free and reallocate all the internal decompression state.
668 The stream will keep attributes that may have been set by inflateInit2.
670 inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
671 stream state was inconsistent (such as zalloc or state being NULL).
675 /* utility functions */
678 The following utility functions are implemented on top of the
679 basic stream-oriented functions. To simplify the interface, some
680 default options are assumed (compression level and memory usage,
681 standard memory allocation functions). The source code of these
682 utility functions can easily be modified if you need special options.
685 int compress OF( ( Byte * dest, uLong * destLen,
686 const Byte * source, uLong sourceLen ) );
688 Compresses the source buffer into the destination buffer. sourceLen is
689 the byte length of the source buffer. Upon entry, destLen is the total
690 size of the destination buffer, which must be at least 0.1% larger than
691 sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
693 This function can be used to compress a whole file at once if the
694 input file is mmap'ed.
695 compress returns Z_OK if success, Z_MEM_ERROR if there was not
696 enough memory, Z_BUF_ERROR if there was not enough room in the output
700 int compress2 OF( ( Byte * dest, uLong * destLen,
701 const Byte * source, uLong sourceLen,
704 Compresses the source buffer into the destination buffer. The level
705 parameter has the same meaning as in deflateInit. sourceLen is the byte
706 length of the source buffer. Upon entry, destLen is the total size of the
707 destination buffer, which must be at least 0.1% larger than sourceLen plus
708 12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
710 compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
711 memory, Z_BUF_ERROR if there was not enough room in the output buffer,
712 Z_STREAM_ERROR if the level parameter is invalid.
715 int uncompress OF( ( Byte * dest, uLong * destLen,
716 const Byte * source, uLong sourceLen ) );
718 Decompresses the source buffer into the destination buffer. sourceLen is
719 the byte length of the source buffer. Upon entry, destLen is the total
720 size of the destination buffer, which must be large enough to hold the
721 entire uncompressed data. (The size of the uncompressed data must have
722 been saved previously by the compressor and transmitted to the decompressor
723 by some mechanism outside the scope of this compression library.)
724 Upon exit, destLen is the actual size of the compressed buffer.
725 This function can be used to decompress a whole file at once if the
726 input file is mmap'ed.
728 uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
729 enough memory, Z_BUF_ERROR if there was not enough room in the output
730 buffer, or Z_DATA_ERROR if the input data was corrupted.
734 typedef voidp gzFile;
736 gzFile gzopen OF( ( const char *path, const char *mode ) );
738 Opens a gzip (.gz) file for reading or writing. The mode parameter
739 is as in fopen ("rb" or "wb") but can also include a compression level
740 ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
741 Huffman only compression as in "wb1h". (See the description
742 of deflateInit2 for more information about the strategy parameter.)
744 gzopen can be used to read a file which is not in gzip format; in this
745 case gzread will directly read from the file without decompression.
747 gzopen returns NULL if the file could not be opened or if there was
748 insufficient memory to allocate the (de)compression state; errno
749 can be checked to distinguish the two cases (if errno is zero, the
750 zlib error is Z_MEM_ERROR). */
752 gzFile gzdopen OF( ( int fd, const char *mode ) );
754 gzdopen() associates a gzFile with the file descriptor fd. File
755 descriptors are obtained from calls like open, dup, creat, pipe or
756 fileno (in the file has been previously opened with fopen).
757 The mode parameter is as in gzopen.
758 The next call of gzclose on the returned gzFile will also close the
759 file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
760 descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
761 gzdopen returns NULL if there was insufficient memory to allocate
762 the (de)compression state.
765 int gzsetparams OF( ( gzFile file, int level, int strategy ) );
767 Dynamically update the compression level or strategy. See the description
768 of deflateInit2 for the meaning of these parameters.
769 gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
773 int gzread OF( ( gzFile file, voidp buf, unsigned len ) );
775 Reads the given number of uncompressed bytes from the compressed file.
776 If the input file was not in gzip format, gzread copies the given number
777 of bytes into the buffer.
778 gzread returns the number of uncompressed bytes actually read (0 for
779 end of file, -1 for error). */
781 int gzwrite OF( ( gzFile file,
782 const voidp buf, unsigned len ) );
784 Writes the given number of uncompressed bytes into the compressed file.
785 gzwrite returns the number of uncompressed bytes actually written
786 (0 in case of error).
789 int gzprintf OF( ( gzFile file, const char *format, ... ) );
791 Converts, formats, and writes the args to the compressed file under
792 control of the format string, as in fprintf. gzprintf returns the number of
793 uncompressed bytes actually written (0 in case of error).
796 int gzputs OF( ( gzFile file, const char *s ) );
798 Writes the given null-terminated string to the compressed file, excluding
799 the terminating null character.
800 gzputs returns the number of characters written, or -1 in case of error.
803 char * gzgets OF( ( gzFile file, char *buf, int len ) );
805 Reads bytes from the compressed file until len-1 characters are read, or
806 a newline character is read and transferred to buf, or an end-of-file
807 condition is encountered. The string is then terminated with a null
809 gzgets returns buf, or Z_NULL in case of error.
812 int gzputc OF( ( gzFile file, int c ) );
814 Writes c, converted to an unsigned char, into the compressed file.
815 gzputc returns the value that was written, or -1 in case of error.
818 int gzgetc OF( (gzFile file) );
820 Reads one byte from the compressed file. gzgetc returns this byte
821 or -1 in case of end of file or error.
824 int gzflush OF( ( gzFile file, int flush ) );
826 Flushes all pending output into the compressed file. The parameter
827 flush is as in the deflate() function. The return value is the zlib
828 error number (see function gzerror below). gzflush returns Z_OK if
829 the flush parameter is Z_FINISH and all output could be flushed.
830 gzflush should be called only when strictly necessary because it can
834 long gzseek OF( ( gzFile file,
835 long offset, int whence ) );
837 Sets the starting position for the next gzread or gzwrite on the
838 given compressed file. The offset represents a number of bytes in the
839 uncompressed data stream. The whence parameter is defined as in lseek(2);
840 the value SEEK_END is not supported.
841 If the file is opened for reading, this function is emulated but can be
842 extremely slow. If the file is opened for writing, only forward seeks are
843 supported; gzseek then compresses a sequence of zeroes up to the new
846 gzseek returns the resulting offset location as measured in bytes from
847 the beginning of the uncompressed stream, or -1 in case of error, in
848 particular if the file is opened for writing and the new starting position
849 would be before the current position.
852 int gzrewind OF( (gzFile file) );
854 Rewinds the given file. This function is supported only for reading.
856 gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
859 long gztell OF( (gzFile file) );
861 Returns the starting position for the next gzread or gzwrite on the
862 given compressed file. This position represents a number of bytes in the
863 uncompressed data stream.
865 gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
868 int gzeof OF( (gzFile file) );
870 Returns 1 when EOF has previously been detected reading the given
871 input stream, otherwise zero.
874 int gzclose OF( (gzFile file) );
876 Flushes all pending output if necessary, closes the compressed file
877 and deallocates all the (de)compression state. The return value is the zlib
878 error number (see function gzerror below).
881 const char * gzerror OF( ( gzFile file, int *errnum ) );
883 Returns the error message for the last error which occurred on the
884 given compressed file. errnum is set to zlib error number. If an
885 error occurred in the file system and not in the compression library,
886 errnum is set to Z_ERRNO and the application may consult errno
887 to get the exact error code.
890 /* checksum functions */
893 These functions are not related to compression but are exported
894 anyway because they might be useful in applications using the
898 uLong adler32 OF( ( uLong adler, const Byte * buf, uInt len ) );
901 Update a running Adler-32 checksum with the bytes buf[0..len-1] and
902 return the updated checksum. If buf is NULL, this function returns
903 the required initial value for the checksum.
904 An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
905 much faster. Usage example:
907 uLong adler = adler32(0L, Z_NULL, 0);
909 while (read_buffer(buffer, length) != EOF) {
910 adler = adler32(adler, buffer, length);
912 if (adler != original_adler) error();
915 uLong crc32 OF( ( uLong crc, const Byte * buf, uInt len ) );
917 Update a running crc with the bytes buf[0..len-1] and return the updated
918 crc. If buf is NULL, this function returns the required initial value
919 for the crc. Pre- and post-conditioning (one's complement) is performed
920 within this function so it shouldn't be done by the application.
923 uLong crc = crc32(0L, Z_NULL, 0);
925 while (read_buffer(buffer, length) != EOF) {
926 crc = crc32(crc, buffer, length);
928 if (crc != original_crc) error();
931 // private stuff to not include cmdlib.h
933 ============================================================================
937 ============================================================================
941 #define __BIG_ENDIAN__
944 #ifdef __BIG_ENDIAN__
946 short __LittleShort( short l ){
950 b2 = ( l >> 8 ) & 255;
952 return ( b1 << 8 ) + b2;
955 short __BigShort( short l ){
960 int __LittleLong( int l ){
964 b2 = ( l >> 8 ) & 255;
965 b3 = ( l >> 16 ) & 255;
966 b4 = ( l >> 24 ) & 255;
968 return ( (int)b1 << 24 ) + ( (int)b2 << 16 ) + ( (int)b3 << 8 ) + b4;
971 int __BigLong( int l ){
976 float __LittleFloat( float l ){
977 union {byte b[4]; float f; } in, out;
988 float __BigFloat( float l ){
996 short __BigShort( short l ){
1000 b2 = ( l >> 8 ) & 255;
1002 return ( b1 << 8 ) + b2;
1005 short __LittleShort( short l ){
1010 int __BigLong( int l ){
1014 b2 = ( l >> 8 ) & 255;
1015 b3 = ( l >> 16 ) & 255;
1016 b4 = ( l >> 24 ) & 255;
1018 return ( (int)b1 << 24 ) + ( (int)b2 << 16 ) + ( (int)b3 << 8 ) + b4;
1021 int __LittleLong( int l ){
1025 float __BigFloat( float l ){
1026 union {byte b[4]; float f; } in, out;
1037 float __LittleFloat( float l ){
1048 /* various hacks, don't look :) */
1050 /* deflateInit and inflateInit are macros to allow checking the zlib version
1051 * and the compiler's view of z_stream:
1053 int deflateInit_ OF( ( z_streamp strm, int level,
1054 const char *version, int stream_size ) );
1055 int inflateInit_ OF( ( z_streamp strm,
1056 const char *version, int stream_size ) );
1057 int deflateInit2_ OF( ( z_streamp strm, int level, int method,
1058 int windowBits, int memLevel,
1059 int strategy, const char *version,
1060 int stream_size ) );
1061 int inflateInit2_ OF( ( z_streamp strm, int windowBits,
1062 const char *version, int stream_size ) );
1063 #define deflateInit( strm, level ) \
1064 deflateInit_( ( strm ), ( level ), ZLIB_VERSION, sizeof( z_stream ) )
1065 #define inflateInit( strm ) \
1066 inflateInit_( ( strm ), ZLIB_VERSION, sizeof( z_stream ) )
1067 #define deflateInit2( strm, level, method, windowBits, memLevel, strategy ) \
1068 deflateInit2_( ( strm ),( level ),( method ),( windowBits ),( memLevel ), \
1069 ( strategy ), ZLIB_VERSION, sizeof( z_stream ) )
1070 #define inflateInit2( strm, windowBits ) \
1071 inflateInit2_( ( strm ), ( windowBits ), ZLIB_VERSION, sizeof( z_stream ) )
1074 const char * zError OF( (int err) );
1075 int inflateSyncPoint OF( (z_streamp z) );
1076 const uLong * get_crc_table OF( (void) );
1078 typedef unsigned char uch;
1079 typedef unsigned short ush;
1080 typedef unsigned long ulg;
1082 extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
1083 /* (size given to avoid silly warnings with Visual C++) */
1085 #define ERR_MSG( err ) z_errmsg[Z_NEED_DICT - ( err )]
1087 #define ERR_RETURN( strm,err ) \
1088 return ( strm->msg = (char*)ERR_MSG( err ), ( err ) )
1089 /* To be used only when the state is known to be valid */
1091 /* common constants */
1094 # define DEF_WBITS MAX_WBITS
1096 /* default windowBits for decompression. MAX_WBITS is for compression only */
1098 #if MAX_MEM_LEVEL >= 8
1099 # define DEF_MEM_LEVEL 8
1101 # define DEF_MEM_LEVEL MAX_MEM_LEVEL
1103 /* default memLevel */
1105 #define STORED_BLOCK 0
1106 #define STATIC_TREES 1
1108 /* The three kinds of block type */
1111 #define MAX_MATCH 258
1112 /* The minimum and maximum match lengths */
1114 #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
1116 /* target dependencies */
1118 /* Common defaults */
1121 # define OS_CODE 0x03 /* assume Unix */
1125 # define F_OPEN( name, mode ) fopen( ( name ), ( mode ) )
1130 #ifdef HAVE_STRERROR
1131 extern char *strerror OF( (int) );
1132 # define zstrerror( errnum ) strerror( errnum )
1134 # define zstrerror( errnum ) ""
1137 #define zmemcpy memcpy
1138 #define zmemcmp memcmp
1139 #define zmemzero( dest, len ) memset( dest, 0, len )
1141 /* Diagnostic functions */
1144 # define Assert( cond,msg ) assert( cond );
1145 //{if(!(cond)) Sys_Error(msg);}
1146 # define Trace( x ) {if ( z_verbose >= 0 ) {Sys_Error x ; }}
1147 # define Tracev( x ) {if ( z_verbose > 0 ) {Sys_Error x ; }}
1148 # define Tracevv( x ) {if ( z_verbose > 1 ) {Sys_Error x ; }}
1149 # define Tracec( c,x ) {if ( z_verbose > 0 && ( c ) ) {Sys_Error x ; }}
1150 # define Tracecv( c,x ) {if ( z_verbose > 1 && ( c ) ) {Sys_Error x ; }}
1152 # define Assert( cond,msg )
1154 # define Tracev( x )
1155 # define Tracevv( x )
1156 # define Tracec( c,x )
1157 # define Tracecv( c,x )
1161 typedef uLong ( *check_func ) OF ( ( uLong check, const Byte * buf, uInt len ) );
1162 voidp zcalloc OF( ( voidp opaque, unsigned items, unsigned size ) );
1163 void zcfree OF( ( voidp opaque, voidp ptr ) );
1165 #define ZALLOC( strm, items, size ) \
1166 ( *( ( strm )->zalloc ) )( ( strm )->opaque, ( items ), ( size ) )
1167 #define ZFREE( strm, addr ) ( *( ( strm )->zfree ) )( ( strm )->opaque, (voidp)( addr ) )
1168 #define TRY_FREE( s, p ) {if ( p ) {ZFREE( s, p ); }}
1171 #if !defined( unix ) && !defined( CASESENSITIVITYDEFAULT_YES ) && \
1172 !defined( CASESENSITIVITYDEFAULT_NO )
1173 #define CASESENSITIVITYDEFAULT_NO
1178 #define UNZ_BUFSIZE ( 65536 )
1181 #ifndef UNZ_MAXFILENAMEINZIP
1182 #define UNZ_MAXFILENAMEINZIP ( 256 )
1186 # define ALLOC( size ) ( malloc( size ) )
1189 # define TRYFREE( p ) {if ( p ) {free( p ); }}
1192 #define SIZECENTRALDIRITEM ( 0x2e )
1193 #define SIZEZIPLOCALHEADER ( 0x1e )
1197 /* ===========================================================================
1198 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
1200 IN assertion: the stream s has been sucessfully opened for reading.
1204 static int unzlocal_getByte(FILE *fin,int *pi)
1207 int err = fread(&c, 1, 1, fin);
1223 /* ===========================================================================
1224 Reads a long in LSB order from the given gz_stream. Sets
1226 static int unzlocal_getShort( FILE* fin, uLong *pX ){
1229 fread( &v, sizeof( v ), 1, fin );
1231 *pX = __LittleShort( v );
1239 err = unzlocal_getByte(fin,&i);
1243 err = unzlocal_getByte(fin,&i);
1254 static int unzlocal_getLong( FILE *fin, uLong *pX ){
1257 fread( &v, sizeof( v ), 1, fin );
1259 *pX = __LittleLong( v );
1267 err = unzlocal_getByte(fin,&i);
1271 err = unzlocal_getByte(fin,&i);
1275 err = unzlocal_getByte(fin,&i);
1276 x += ((uLong)i)<<16;
1279 err = unzlocal_getByte(fin,&i);
1280 x += ((uLong)i)<<24;
1291 /* My own strcmpi / strcasecmp */
1292 static int strcmpcasenosensitive_internal( const char* fileName1,const char* fileName2 ){
1295 char c1 = *( fileName1++ );
1296 char c2 = *( fileName2++ );
1297 if ( ( c1 >= 'a' ) && ( c1 <= 'z' ) ) {
1300 if ( ( c2 >= 'a' ) && ( c2 <= 'z' ) ) {
1304 return ( ( c2 == '\0' ) ? 0 : -1 );
1319 #ifdef CASESENSITIVITYDEFAULT_NO
1320 #define CASESENSITIVITYDEFAULTVALUE 2
1322 #define CASESENSITIVITYDEFAULTVALUE 1
1325 #ifndef STRCMPCASENOSENTIVEFUNCTION
1326 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
1330 Compare two filename (fileName1,fileName2).
1331 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
1332 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
1334 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
1335 (like 1 on Unix, 2 on Windows)
1338 extern int unzStringFileNameCompare( const char* fileName1,const char* fileName2,int iCaseSensitivity ){
1339 if ( iCaseSensitivity == 0 ) {
1340 iCaseSensitivity = CASESENSITIVITYDEFAULTVALUE;
1343 if ( iCaseSensitivity == 1 ) {
1344 return strcmp( fileName1,fileName2 );
1347 return STRCMPCASENOSENTIVEFUNCTION( fileName1,fileName2 );
1350 #define BUFREADCOMMENT ( 0x400 )
1353 Locate the Central directory of a zipfile (at the end, just before
1356 static uLong unzlocal_SearchCentralDir( FILE *fin ){
1360 uLong uMaxBack = 0xffff; /* maximum size of global comment */
1361 uLong uPosFound = 0;
1363 if ( fseek( fin,0,SEEK_END ) != 0 ) {
1368 uSizeFile = ftell( fin );
1370 if ( uMaxBack > uSizeFile ) {
1371 uMaxBack = uSizeFile;
1374 buf = (unsigned char*)malloc( BUFREADCOMMENT + 4 );
1375 if ( buf == NULL ) {
1380 while ( uBackRead < uMaxBack )
1382 uLong uReadSize,uReadPos ;
1384 if ( uBackRead + BUFREADCOMMENT > uMaxBack ) {
1385 uBackRead = uMaxBack;
1388 uBackRead += BUFREADCOMMENT;
1390 uReadPos = uSizeFile - uBackRead ;
1392 uReadSize = ( ( BUFREADCOMMENT + 4 ) < ( uSizeFile - uReadPos ) ) ?
1393 ( BUFREADCOMMENT + 4 ) : ( uSizeFile - uReadPos );
1394 if ( fseek( fin,uReadPos,SEEK_SET ) != 0 ) {
1398 if ( fread( buf,(uInt)uReadSize,1,fin ) != 1 ) {
1402 for ( i = (int)uReadSize - 3; ( i-- ) > 0; )
1403 if ( ( ( *( buf + i ) ) == 0x50 ) && ( ( *( buf + i + 1 ) ) == 0x4b ) &&
1404 ( ( *( buf + i + 2 ) ) == 0x05 ) && ( ( *( buf + i + 3 ) ) == 0x06 ) ) {
1405 uPosFound = uReadPos + i;
1409 if ( uPosFound != 0 ) {
1417 extern unzFile unzReOpen( const char* path, unzFile file ){
1421 fin = fopen( path,"rb" );
1422 if ( fin == NULL ) {
1426 s = (unz_s*)malloc( sizeof( unz_s ) );
1427 memcpy( s, (unz_s*)file, sizeof( unz_s ) );
1434 Open a Zip file. path contain the full pathname (by example,
1435 on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
1437 If the zipfile cannot be opened (file don't exist or in not valid), the
1438 return value is NULL.
1439 Else, the return value is a unzFile Handle, usable with other function
1440 of this unzip package.
1442 extern unzFile unzOpen( const char* path ){
1445 uLong central_pos,uL;
1448 uLong number_disk; /* number of the current dist, used for
1449 spaning ZIP, unsupported, always 0*/
1450 uLong number_disk_with_CD; /* number the the disk with central dir, used
1451 for spaning ZIP, unsupported, always 0*/
1452 uLong number_entry_CD; /* total number of entries in
1454 (same than number_entry on nospan) */
1458 fin = fopen( path,"rb" );
1459 if ( fin == NULL ) {
1463 central_pos = unzlocal_SearchCentralDir( fin );
1464 if ( central_pos == 0 ) {
1468 if ( fseek( fin,central_pos,SEEK_SET ) != 0 ) {
1472 /* the signature, already checked */
1473 if ( unzlocal_getLong( fin,&uL ) != UNZ_OK ) {
1477 /* number of this disk */
1478 if ( unzlocal_getShort( fin,&number_disk ) != UNZ_OK ) {
1482 /* number of the disk with the start of the central directory */
1483 if ( unzlocal_getShort( fin,&number_disk_with_CD ) != UNZ_OK ) {
1487 /* total number of entries in the central dir on this disk */
1488 if ( unzlocal_getShort( fin,&us.gi.number_entry ) != UNZ_OK ) {
1492 /* total number of entries in the central dir */
1493 if ( unzlocal_getShort( fin,&number_entry_CD ) != UNZ_OK ) {
1497 if ( ( number_entry_CD != us.gi.number_entry ) ||
1498 ( number_disk_with_CD != 0 ) ||
1499 ( number_disk != 0 ) ) {
1500 err = UNZ_BADZIPFILE;
1503 /* size of the central directory */
1504 if ( unzlocal_getLong( fin,&us.size_central_dir ) != UNZ_OK ) {
1508 /* offset of start of central directory with respect to the
1509 starting disk number */
1510 if ( unzlocal_getLong( fin,&us.offset_central_dir ) != UNZ_OK ) {
1514 /* zipfile comment length */
1515 if ( unzlocal_getShort( fin,&us.gi.size_comment ) != UNZ_OK ) {
1519 if ( ( central_pos < us.offset_central_dir + us.size_central_dir ) &&
1520 ( err == UNZ_OK ) ) {
1521 err = UNZ_BADZIPFILE;
1524 if ( err != UNZ_OK ) {
1530 us.byte_before_the_zipfile = central_pos -
1531 ( us.offset_central_dir + us.size_central_dir );
1532 us.central_pos = central_pos;
1533 us.pfile_in_zip_read = NULL;
1536 s = (unz_s*)malloc( sizeof( unz_s ) );
1538 // unzGoToFirstFile((unzFile)s);
1544 Close a ZipFile opened with unzipOpen.
1545 If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
1546 these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
1547 return UNZ_OK if there is no problem. */
1548 extern int unzClose( unzFile file ){
1550 if ( file == NULL ) {
1551 return UNZ_PARAMERROR;
1555 if ( s->pfile_in_zip_read != NULL ) {
1556 unzCloseCurrentFile( file );
1566 Write info about the ZipFile in the *pglobal_info structure.
1567 No preparation of the structure is needed
1568 return UNZ_OK if there is no problem. */
1569 extern int unzGetGlobalInfo( unzFile file,unz_global_info *pglobal_info ){
1571 if ( file == NULL ) {
1572 return UNZ_PARAMERROR;
1575 *pglobal_info = s->gi;
1581 Translate date/time from Dos format to tm_unz (readable more easilty)
1583 static void unzlocal_DosDateToTmuDate( uLong ulDosDate, tm_unz* ptm ){
1585 uDate = (uLong)( ulDosDate >> 16 );
1586 ptm->tm_mday = (uInt)( uDate & 0x1f ) ;
1587 ptm->tm_mon = (uInt)( ( ( ( uDate ) & 0x1E0 ) / 0x20 ) - 1 ) ;
1588 ptm->tm_year = (uInt)( ( ( uDate & 0x0FE00 ) / 0x0200 ) + 1980 ) ;
1590 ptm->tm_hour = (uInt) ( ( ulDosDate & 0xF800 ) / 0x800 );
1591 ptm->tm_min = (uInt) ( ( ulDosDate & 0x7E0 ) / 0x20 ) ;
1592 ptm->tm_sec = (uInt) ( 2 * ( ulDosDate & 0x1f ) ) ;
1596 Get Info about the current file in the zipfile, with internal only info
1598 static int unzlocal_GetCurrentFileInfoInternal( unzFile file,
1599 unz_file_info *pfile_info,
1600 unz_file_info_internal
1601 *pfile_info_internal,
1603 uLong fileNameBufferSize,
1605 uLong extraFieldBufferSize,
1607 uLong commentBufferSize ){
1609 unz_file_info file_info;
1610 unz_file_info_internal file_info_internal;
1615 if ( file == NULL ) {
1616 return UNZ_PARAMERROR;
1619 if ( fseek( s->file,s->pos_in_central_dir + s->byte_before_the_zipfile,SEEK_SET ) != 0 ) {
1624 /* we check the magic */
1625 if ( err == UNZ_OK ) {
1626 if ( unzlocal_getLong( s->file,&uMagic ) != UNZ_OK ) {
1629 else if ( uMagic != 0x02014b50 ) {
1630 err = UNZ_BADZIPFILE;
1634 if ( unzlocal_getShort( s->file,&file_info.version ) != UNZ_OK ) {
1638 if ( unzlocal_getShort( s->file,&file_info.version_needed ) != UNZ_OK ) {
1642 if ( unzlocal_getShort( s->file,&file_info.flag ) != UNZ_OK ) {
1646 if ( unzlocal_getShort( s->file,&file_info.compression_method ) != UNZ_OK ) {
1650 if ( unzlocal_getLong( s->file,&file_info.dosDate ) != UNZ_OK ) {
1654 unzlocal_DosDateToTmuDate( file_info.dosDate,&file_info.tmu_date );
1656 if ( unzlocal_getLong( s->file,&file_info.crc ) != UNZ_OK ) {
1660 if ( unzlocal_getLong( s->file,&file_info.compressed_size ) != UNZ_OK ) {
1664 if ( unzlocal_getLong( s->file,&file_info.uncompressed_size ) != UNZ_OK ) {
1668 if ( unzlocal_getShort( s->file,&file_info.size_filename ) != UNZ_OK ) {
1672 if ( unzlocal_getShort( s->file,&file_info.size_file_extra ) != UNZ_OK ) {
1676 if ( unzlocal_getShort( s->file,&file_info.size_file_comment ) != UNZ_OK ) {
1680 if ( unzlocal_getShort( s->file,&file_info.disk_num_start ) != UNZ_OK ) {
1684 if ( unzlocal_getShort( s->file,&file_info.internal_fa ) != UNZ_OK ) {
1688 if ( unzlocal_getLong( s->file,&file_info.external_fa ) != UNZ_OK ) {
1692 if ( unzlocal_getLong( s->file,&file_info_internal.offset_curfile ) != UNZ_OK ) {
1696 lSeek += file_info.size_filename;
1697 if ( ( err == UNZ_OK ) && ( szFileName != NULL ) ) {
1699 if ( file_info.size_filename < fileNameBufferSize ) {
1700 *( szFileName + file_info.size_filename ) = '\0';
1701 uSizeRead = file_info.size_filename;
1704 uSizeRead = fileNameBufferSize;
1707 if ( ( file_info.size_filename > 0 ) && ( fileNameBufferSize > 0 ) ) {
1708 if ( fread( szFileName,(uInt)uSizeRead,1,s->file ) != 1 ) {
1716 if ( ( err == UNZ_OK ) && ( extraField != NULL ) ) {
1718 if ( file_info.size_file_extra < extraFieldBufferSize ) {
1719 uSizeRead = file_info.size_file_extra;
1722 uSizeRead = extraFieldBufferSize;
1726 if ( fseek( s->file,lSeek,SEEK_CUR ) == 0 ) {
1733 if ( ( file_info.size_file_extra > 0 ) && ( extraFieldBufferSize > 0 ) ) {
1734 if ( fread( extraField,(uInt)uSizeRead,1,s->file ) != 1 ) {
1738 lSeek += file_info.size_file_extra - uSizeRead;
1741 lSeek += file_info.size_file_extra;
1745 if ( ( err == UNZ_OK ) && ( szComment != NULL ) ) {
1747 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;
1756 if ( fseek( s->file,lSeek,SEEK_CUR ) == 0 ) {
1763 if ( ( file_info.size_file_comment > 0 ) && ( commentBufferSize > 0 ) ) {
1764 if ( fread( szComment,(uInt)uSizeRead,1,s->file ) != 1 ) {
1768 lSeek += file_info.size_file_comment - uSizeRead;
1771 lSeek += file_info.size_file_comment;
1774 if ( ( err == UNZ_OK ) && ( pfile_info != NULL ) ) {
1775 *pfile_info = file_info;
1778 if ( ( err == UNZ_OK ) && ( pfile_info_internal != NULL ) ) {
1779 *pfile_info_internal = file_info_internal;
1788 Write info about the ZipFile in the *pglobal_info structure.
1789 No preparation of the structure is needed
1790 return UNZ_OK if there is no problem.
1792 extern int unzGetCurrentFileInfo( unzFile file, unz_file_info *pfile_info,
1793 char *szFileName, uLong fileNameBufferSize,
1794 void *extraField, uLong extraFieldBufferSize,
1795 char *szComment, uLong commentBufferSize ){
1796 return unzlocal_GetCurrentFileInfoInternal( file,pfile_info,NULL,
1797 szFileName,fileNameBufferSize,
1798 extraField,extraFieldBufferSize,
1799 szComment,commentBufferSize );
1803 Set the current file of the zipfile to the first file.
1804 return UNZ_OK if there is no problem
1806 extern int unzGoToFirstFile( unzFile file ){
1809 if ( file == NULL ) {
1810 return UNZ_PARAMERROR;
1813 s->pos_in_central_dir = s->offset_central_dir;
1815 err = unzlocal_GetCurrentFileInfoInternal( file,&s->cur_file_info,
1816 &s->cur_file_info_internal,
1817 NULL,0,NULL,0,NULL,0 );
1818 s->current_file_ok = ( err == UNZ_OK );
1824 Set the current file of the zipfile to the next file.
1825 return UNZ_OK if there is no problem
1826 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
1828 extern int unzGoToNextFile( unzFile file ){
1832 if ( file == NULL ) {
1833 return UNZ_PARAMERROR;
1836 if ( !s->current_file_ok ) {
1837 return UNZ_END_OF_LIST_OF_FILE;
1839 if ( s->num_file + 1 == s->gi.number_entry ) {
1840 return UNZ_END_OF_LIST_OF_FILE;
1843 s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
1844 s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
1846 err = unzlocal_GetCurrentFileInfoInternal( file,&s->cur_file_info,
1847 &s->cur_file_info_internal,
1848 NULL,0,NULL,0,NULL,0 );
1849 s->current_file_ok = ( err == UNZ_OK );
1855 Try locate the file szFileName in the zipfile.
1856 For the iCaseSensitivity signification, see unzipStringFileNameCompare
1859 UNZ_OK if the file is found. It becomes the current file.
1860 UNZ_END_OF_LIST_OF_FILE if the file is not found
1862 extern int unzLocateFile( unzFile file, const char *szFileName, int iCaseSensitivity ){
1867 uLong num_fileSaved;
1868 uLong pos_in_central_dirSaved;
1871 if ( file == NULL ) {
1872 return UNZ_PARAMERROR;
1875 if ( strlen( szFileName ) >= UNZ_MAXFILENAMEINZIP ) {
1876 return UNZ_PARAMERROR;
1880 if ( !s->current_file_ok ) {
1881 return UNZ_END_OF_LIST_OF_FILE;
1884 num_fileSaved = s->num_file;
1885 pos_in_central_dirSaved = s->pos_in_central_dir;
1887 err = unzGoToFirstFile( file );
1889 while ( err == UNZ_OK )
1891 char szCurrentFileName[UNZ_MAXFILENAMEINZIP + 1];
1892 unzGetCurrentFileInfo( file,NULL,
1893 szCurrentFileName,sizeof( szCurrentFileName ) - 1,
1895 if ( unzStringFileNameCompare( szCurrentFileName,
1896 szFileName,iCaseSensitivity ) == 0 ) {
1899 err = unzGoToNextFile( file );
1902 s->num_file = num_fileSaved ;
1903 s->pos_in_central_dir = pos_in_central_dirSaved ;
1909 Read the static header of the current zipfile
1910 Check the coherency of the static header and info in the end of central
1911 directory about this file
1912 store in *piSizeVar the size of extra info in static header
1913 (filename and size of extra field data)
1915 static int unzlocal_CheckCurrentFileCoherencyHeader( unz_s* s, uInt* piSizeVar,
1916 uLong *poffset_local_extrafield,
1917 uInt *psize_local_extrafield ){
1918 uLong uMagic,uData,uFlags;
1919 uLong size_filename;
1920 uLong size_extra_field;
1924 *poffset_local_extrafield = 0;
1925 *psize_local_extrafield = 0;
1927 if ( fseek( s->file,s->cur_file_info_internal.offset_curfile +
1928 s->byte_before_the_zipfile,SEEK_SET ) != 0 ) {
1933 if ( err == UNZ_OK ) {
1934 if ( unzlocal_getLong( s->file,&uMagic ) != UNZ_OK ) {
1937 else if ( uMagic != 0x04034b50 ) {
1938 err = UNZ_BADZIPFILE;
1942 if ( unzlocal_getShort( s->file,&uData ) != UNZ_OK ) {
1946 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
1949 if ( unzlocal_getShort( s->file,&uFlags ) != UNZ_OK ) {
1953 if ( unzlocal_getShort( s->file,&uData ) != UNZ_OK ) {
1956 else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.compression_method ) ) {
1957 err = UNZ_BADZIPFILE;
1960 if ( ( err == UNZ_OK ) && ( s->cur_file_info.compression_method != 0 ) &&
1961 ( s->cur_file_info.compression_method != Z_DEFLATED ) ) {
1962 err = UNZ_BADZIPFILE;
1965 if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* date/time */
1969 if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* crc */
1972 else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.crc ) &&
1973 ( ( uFlags & 8 ) == 0 ) ) {
1974 err = UNZ_BADZIPFILE;
1977 if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* size compr */
1980 else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.compressed_size ) &&
1981 ( ( uFlags & 8 ) == 0 ) ) {
1982 err = UNZ_BADZIPFILE;
1985 if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* size uncompr */
1988 else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.uncompressed_size ) &&
1989 ( ( uFlags & 8 ) == 0 ) ) {
1990 err = UNZ_BADZIPFILE;
1994 if ( unzlocal_getShort( s->file,&size_filename ) != UNZ_OK ) {
1997 else if ( ( err == UNZ_OK ) && ( size_filename != s->cur_file_info.size_filename ) ) {
1998 err = UNZ_BADZIPFILE;
2001 *piSizeVar += (uInt)size_filename;
2003 if ( unzlocal_getShort( s->file,&size_extra_field ) != UNZ_OK ) {
2006 *poffset_local_extrafield = s->cur_file_info_internal.offset_curfile +
2007 SIZEZIPLOCALHEADER + size_filename;
2008 *psize_local_extrafield = (uInt)size_extra_field;
2010 *piSizeVar += (uInt)size_extra_field;
2016 Open for reading data the current file in the zipfile.
2017 If there is no error and the file is opened, the return value is UNZ_OK.
2019 extern int unzOpenCurrentFile( unzFile file ){
2024 file_in_zip_read_info_s* pfile_in_zip_read_info;
2025 uLong offset_local_extrafield; /* offset of the static extra field */
2026 uInt size_local_extrafield; /* size of the static extra field */
2028 if ( file == NULL ) {
2029 return UNZ_PARAMERROR;
2032 if ( !s->current_file_ok ) {
2033 return UNZ_PARAMERROR;
2036 if ( s->pfile_in_zip_read != NULL ) {
2037 unzCloseCurrentFile( file );
2040 if ( unzlocal_CheckCurrentFileCoherencyHeader( s,&iSizeVar,
2041 &offset_local_extrafield,&size_local_extrafield ) != UNZ_OK ) {
2042 return UNZ_BADZIPFILE;
2045 pfile_in_zip_read_info = (file_in_zip_read_info_s*)
2046 malloc( sizeof( file_in_zip_read_info_s ) );
2047 if ( pfile_in_zip_read_info == NULL ) {
2048 return UNZ_INTERNALERROR;
2051 pfile_in_zip_read_info->read_buffer = (char*)malloc( UNZ_BUFSIZE );
2052 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
2053 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
2054 pfile_in_zip_read_info->pos_local_extrafield = 0;
2056 if ( pfile_in_zip_read_info->read_buffer == NULL ) {
2057 free( pfile_in_zip_read_info );
2058 return UNZ_INTERNALERROR;
2061 pfile_in_zip_read_info->stream_initialised = 0;
2063 if ( ( s->cur_file_info.compression_method != 0 ) &&
2064 ( s->cur_file_info.compression_method != Z_DEFLATED ) ) {
2065 err = UNZ_BADZIPFILE;
2067 Store = s->cur_file_info.compression_method == 0;
2069 pfile_in_zip_read_info->crc32_wait = s->cur_file_info.crc;
2070 pfile_in_zip_read_info->crc32 = 0;
2071 pfile_in_zip_read_info->compression_method =
2072 s->cur_file_info.compression_method;
2073 pfile_in_zip_read_info->file = s->file;
2074 pfile_in_zip_read_info->byte_before_the_zipfile = s->byte_before_the_zipfile;
2076 pfile_in_zip_read_info->stream.total_out = 0;
2079 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
2080 pfile_in_zip_read_info->stream.zfree = (free_func)0;
2081 pfile_in_zip_read_info->stream.opaque = (voidp)0;
2083 err = inflateInit2( &pfile_in_zip_read_info->stream, -MAX_WBITS );
2084 if ( err == Z_OK ) {
2085 pfile_in_zip_read_info->stream_initialised = 1;
2087 /* windowBits is passed < 0 to tell that there is no zlib header.
2088 * Note that in this case inflate *requires* an extra "dummy" byte
2089 * after the compressed stream in order to complete decompression and
2090 * return Z_STREAM_END.
2091 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2092 * size of both compressed and uncompressed data
2095 pfile_in_zip_read_info->rest_read_compressed =
2096 s->cur_file_info.compressed_size ;
2097 pfile_in_zip_read_info->rest_read_uncompressed =
2098 s->cur_file_info.uncompressed_size ;
2101 pfile_in_zip_read_info->pos_in_zipfile =
2102 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
2105 pfile_in_zip_read_info->stream.avail_in = (uInt)0;
2108 s->pfile_in_zip_read = pfile_in_zip_read_info;
2114 Read bytes from the current file.
2115 buf contain buffer where data must be copied
2116 len the size of buf.
2118 return the number of byte copied if somes bytes are copied
2119 return 0 if the end of file was reached
2120 return <0 with error code if there is an error
2121 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
2123 extern int unzReadCurrentFile( unzFile file, void *buf, unsigned len ){
2127 file_in_zip_read_info_s* pfile_in_zip_read_info;
2128 if ( file == NULL ) {
2129 return UNZ_PARAMERROR;
2132 pfile_in_zip_read_info = s->pfile_in_zip_read;
2134 if ( pfile_in_zip_read_info == NULL ) {
2135 return UNZ_PARAMERROR;
2139 if ( ( pfile_in_zip_read_info->read_buffer == NULL ) ) {
2140 return UNZ_END_OF_LIST_OF_FILE;
2146 pfile_in_zip_read_info->stream.next_out = (Byte*)buf;
2148 pfile_in_zip_read_info->stream.avail_out = (uInt)len;
2150 if ( len > pfile_in_zip_read_info->rest_read_uncompressed ) {
2151 pfile_in_zip_read_info->stream.avail_out =
2152 (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
2155 while ( pfile_in_zip_read_info->stream.avail_out > 0 )
2157 if ( ( pfile_in_zip_read_info->stream.avail_in == 0 ) &&
2158 ( pfile_in_zip_read_info->rest_read_compressed > 0 ) ) {
2159 uInt uReadThis = UNZ_BUFSIZE;
2160 if ( pfile_in_zip_read_info->rest_read_compressed < uReadThis ) {
2161 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
2163 if ( uReadThis == 0 ) {
2166 if ( s->cur_file_info.compressed_size == pfile_in_zip_read_info->rest_read_compressed ) {
2167 if ( fseek( pfile_in_zip_read_info->file,
2168 pfile_in_zip_read_info->pos_in_zipfile +
2169 pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET ) != 0 ) {
2173 if ( fread( pfile_in_zip_read_info->read_buffer,uReadThis,1,
2174 pfile_in_zip_read_info->file ) != 1 ) {
2177 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
2179 pfile_in_zip_read_info->rest_read_compressed -= uReadThis;
2181 pfile_in_zip_read_info->stream.next_in =
2182 (Byte*)pfile_in_zip_read_info->read_buffer;
2183 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
2186 if ( pfile_in_zip_read_info->compression_method == 0 ) {
2188 if ( pfile_in_zip_read_info->stream.avail_out <
2189 pfile_in_zip_read_info->stream.avail_in ) {
2190 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
2193 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
2196 for ( i = 0; i < uDoCopy; i++ )
2197 *( pfile_in_zip_read_info->stream.next_out + i ) =
2198 *( pfile_in_zip_read_info->stream.next_in + i );
2200 pfile_in_zip_read_info->crc32 = crc32( pfile_in_zip_read_info->crc32,
2201 pfile_in_zip_read_info->stream.next_out,
2203 pfile_in_zip_read_info->rest_read_uncompressed -= uDoCopy;
2204 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
2205 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
2206 pfile_in_zip_read_info->stream.next_out += uDoCopy;
2207 pfile_in_zip_read_info->stream.next_in += uDoCopy;
2208 pfile_in_zip_read_info->stream.total_out += uDoCopy;
2213 uLong uTotalOutBefore,uTotalOutAfter;
2214 const Byte *bufBefore;
2216 int flush = Z_SYNC_FLUSH;
2218 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
2219 bufBefore = pfile_in_zip_read_info->stream.next_out;
2222 if ((pfile_in_zip_read_info->rest_read_uncompressed ==
2223 pfile_in_zip_read_info->stream.avail_out) &&
2224 (pfile_in_zip_read_info->rest_read_compressed == 0))
2227 err = inflate( &pfile_in_zip_read_info->stream,flush );
2229 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
2230 uOutThis = uTotalOutAfter - uTotalOutBefore;
2232 pfile_in_zip_read_info->crc32 =
2233 crc32( pfile_in_zip_read_info->crc32,bufBefore,
2234 (uInt)( uOutThis ) );
2236 pfile_in_zip_read_info->rest_read_uncompressed -=
2239 iRead += (uInt)( uTotalOutAfter - uTotalOutBefore );
2241 if ( err == Z_STREAM_END ) {
2242 return ( iRead == 0 ) ? UNZ_EOF : iRead;
2244 if ( err != Z_OK ) {
2250 if ( err == Z_OK ) {
2258 Give the current position in uncompressed data
2260 extern long unztell( unzFile file ){
2262 file_in_zip_read_info_s* pfile_in_zip_read_info;
2263 if ( file == NULL ) {
2264 return UNZ_PARAMERROR;
2267 pfile_in_zip_read_info = s->pfile_in_zip_read;
2269 if ( pfile_in_zip_read_info == NULL ) {
2270 return UNZ_PARAMERROR;
2273 return (long)pfile_in_zip_read_info->stream.total_out;
2278 return 1 if the end of file was reached, 0 elsewhere
2280 extern int unzeof( unzFile file ){
2282 file_in_zip_read_info_s* pfile_in_zip_read_info;
2283 if ( file == NULL ) {
2284 return UNZ_PARAMERROR;
2287 pfile_in_zip_read_info = s->pfile_in_zip_read;
2289 if ( pfile_in_zip_read_info == NULL ) {
2290 return UNZ_PARAMERROR;
2293 if ( pfile_in_zip_read_info->rest_read_uncompressed == 0 ) {
2304 Read extra field from the current file (opened by unzOpenCurrentFile)
2305 This is the static-header version of the extra field (sometimes, there is
2306 more info in the static-header version than in the central-header)
2308 if buf==NULL, it return the size of the static extra field that can be read
2310 if buf!=NULL, len is the size of the buffer, the extra header is copied in
2312 the return value is the number of bytes copied in buf, or (if <0)
2315 extern int unzGetLocalExtrafield( unzFile file,void *buf,unsigned len ){
2317 file_in_zip_read_info_s* pfile_in_zip_read_info;
2321 if ( file == NULL ) {
2322 return UNZ_PARAMERROR;
2325 pfile_in_zip_read_info = s->pfile_in_zip_read;
2327 if ( pfile_in_zip_read_info == NULL ) {
2328 return UNZ_PARAMERROR;
2331 size_to_read = ( pfile_in_zip_read_info->size_local_extrafield -
2332 pfile_in_zip_read_info->pos_local_extrafield );
2334 if ( buf == NULL ) {
2335 return (int)size_to_read;
2338 if ( len > size_to_read ) {
2339 read_now = (uInt)size_to_read;
2342 read_now = (uInt)len ;
2345 if ( read_now == 0 ) {
2349 if ( fseek( pfile_in_zip_read_info->file,
2350 pfile_in_zip_read_info->offset_local_extrafield +
2351 pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET ) != 0 ) {
2355 if ( fread( buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file ) != 1 ) {
2359 return (int)read_now;
2363 Close the file in zip opened with unzipOpenCurrentFile
2364 Return UNZ_CRCERROR if all the file was read but the CRC is not good
2366 extern int unzCloseCurrentFile( unzFile file ){
2370 file_in_zip_read_info_s* pfile_in_zip_read_info;
2371 if ( file == NULL ) {
2372 return UNZ_PARAMERROR;
2375 pfile_in_zip_read_info = s->pfile_in_zip_read;
2377 if ( pfile_in_zip_read_info == NULL ) {
2378 return UNZ_PARAMERROR;
2382 if ( pfile_in_zip_read_info->rest_read_uncompressed == 0 ) {
2383 if ( pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait ) {
2389 free( pfile_in_zip_read_info->read_buffer );
2390 pfile_in_zip_read_info->read_buffer = NULL;
2391 if ( pfile_in_zip_read_info->stream_initialised ) {
2392 inflateEnd( &pfile_in_zip_read_info->stream );
2395 pfile_in_zip_read_info->stream_initialised = 0;
2396 free( pfile_in_zip_read_info );
2398 s->pfile_in_zip_read = NULL;
2405 Get the global comment string of the ZipFile, in the szComment buffer.
2406 uSizeBuf is the size of the szComment buffer.
2407 return the number of byte copied or an error code <0
2409 extern int unzGetGlobalComment( unzFile file, char *szComment, uLong uSizeBuf ){
2412 if ( file == NULL ) {
2413 return UNZ_PARAMERROR;
2417 uReadThis = uSizeBuf;
2418 if ( uReadThis > s->gi.size_comment ) {
2419 uReadThis = s->gi.size_comment;
2422 if ( fseek( s->file,s->central_pos + 22,SEEK_SET ) != 0 ) {
2426 if ( uReadThis > 0 ) {
2428 if ( fread( szComment,(uInt)uReadThis,1,s->file ) != 1 ) {
2433 if ( ( szComment != NULL ) && ( uSizeBuf > s->gi.size_comment ) ) {
2434 *( szComment + s->gi.size_comment ) = '\0';
2436 return (int)uReadThis;
2439 /* crc32.c -- compute the CRC-32 of a data stream
2440 * Copyright (C) 1995-1998 Mark Adler
2441 * For conditions of distribution and use, see copyright notice in zlib.h
2445 #ifdef DYNAMIC_CRC_TABLE
2447 static int crc_table_empty = 1;
2448 static uLong crc_table[256];
2449 static void make_crc_table OF( (void) );
2452 Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
2453 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.
2455 Polynomials over GF(2) are represented in binary, one bit per coefficient,
2456 with the lowest powers in the most significant bit. Then adding polynomials
2457 is just exclusive-or, and multiplying a polynomial by x is a right shift by
2458 one. If we call the above polynomial p, and represent a byte as the
2459 polynomial q, also with the lowest power in the most significant bit (so the
2460 byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
2461 where a mod b means the remainder after dividing a by b.
2463 This calculation is done using the shift-register method of multiplying and
2464 taking the remainder. The register is initialized to zero, and for each
2465 incoming bit, x^32 is added mod p to the register if the bit is a one (where
2466 x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
2467 x (which is shifting right by one and adding x^32 mod p if the bit shifted
2468 out is a one). We start with the highest power (least significant bit) of
2469 q and repeat for all eight bits of q.
2471 The table is simply the CRC of all possible eight bit values. This is all
2472 the information needed to generate CRC's on data a byte at a time for all
2473 combinations of CRC register values and incoming bytes.
2475 static void make_crc_table(){
2478 uLong poly; /* polynomial exclusive-or pattern */
2479 /* terms of polynomial defining this crc (except x^32): */
2480 static const Byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
2482 /* make exclusive-or pattern from polynomial (0xedb88320L) */
2484 for ( n = 0; n < sizeof( p ) / sizeof( Byte ); n++ )
2485 poly |= 1L << ( 31 - p[n] );
2487 for ( n = 0; n < 256; n++ )
2490 for ( k = 0; k < 8; k++ )
2491 c = c & 1 ? poly ^ ( c >> 1 ) : c >> 1;
2494 crc_table_empty = 0;
2497 /* ========================================================================
2498 * Table of CRC-32's of all single-byte values (made by make_crc_table)
2500 static const uLong crc_table[256] = {
2501 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
2502 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
2503 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
2504 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
2505 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
2506 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
2507 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
2508 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
2509 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
2510 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
2511 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
2512 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
2513 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
2514 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
2515 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
2516 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
2517 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
2518 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
2519 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
2520 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
2521 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
2522 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
2523 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
2524 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
2525 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
2526 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
2527 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
2528 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
2529 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
2530 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
2531 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
2532 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
2533 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
2534 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
2535 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
2536 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
2537 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
2538 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
2539 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
2540 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
2541 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
2542 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
2543 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
2544 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
2545 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
2546 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
2547 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
2548 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
2549 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
2550 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
2551 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
2556 /* =========================================================================
2557 * This function can be used by asm versions of crc32()
2559 const uLong * get_crc_table(){
2560 #ifdef DYNAMIC_CRC_TABLE
2561 if ( crc_table_empty ) {
2565 return (const uLong *)crc_table;
2568 /* ========================================================================= */
2569 #define DO1( buf ) crc = crc_table[( (int)crc ^ ( *buf++ ) ) & 0xff] ^ ( crc >> 8 );
2570 #define DO2( buf ) DO1( buf ); DO1( buf );
2571 #define DO4( buf ) DO2( buf ); DO2( buf );
2572 #define DO8( buf ) DO4( buf ); DO4( buf );
2574 /* ========================================================================= */
2575 uLong crc32( uLong crc, const Byte *buf, uInt len ){
2576 if ( buf == Z_NULL ) {
2579 #ifdef DYNAMIC_CRC_TABLE
2580 if ( crc_table_empty ) {
2584 crc = crc ^ 0xffffffffL;
2595 return crc ^ 0xffffffffL;
2598 /* infblock.h -- header to use infblock.c
2599 * Copyright (C) 1995-1998 Mark Adler
2600 * For conditions of distribution and use, see copyright notice in zlib.h
2603 /* WARNING: this file should *not* be used by applications. It is
2604 part of the implementation of the compression library and is
2605 subject to change. Applications should only use zlib.h.
2608 struct inflate_blocks_state;
2609 typedef struct inflate_blocks_state inflate_blocks_statef;
2611 extern inflate_blocks_statef * inflate_blocks_new OF( (
2613 check_func c, /* check function */
2614 uInt w ) ); /* window size */
2616 extern int inflate_blocks OF( (
2617 inflate_blocks_statef *,
2619 int ) ); /* initial return code */
2621 extern void inflate_blocks_reset OF( (
2622 inflate_blocks_statef *,
2624 uLong * ) ); /* check value on output */
2626 extern int inflate_blocks_free OF( (
2627 inflate_blocks_statef *,
2630 extern void inflate_set_dictionary OF( (
2631 inflate_blocks_statef * s,
2632 const Byte * d, /* dictionary */
2633 uInt n ) ); /* dictionary length */
2635 extern int inflate_blocks_sync_point OF( (
2636 inflate_blocks_statef * s ) );
2638 /* simplify the use of the inflate_huft type with some defines */
2639 #define exop word.what.Exop
2640 #define bits word.what.Bits
2642 /* Table for deflate from PKZIP's appnote.txt. */
2643 static const uInt border[] = { /* Order of the bit length code lengths */
2644 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
2647 /* inftrees.h -- header to use inftrees.c
2648 * Copyright (C) 1995-1998 Mark Adler
2649 * For conditions of distribution and use, see copyright notice in zlib.h
2652 /* WARNING: this file should *not* be used by applications. It is
2653 part of the implementation of the compression library and is
2654 subject to change. Applications should only use zlib.h.
2657 /* Huffman code lookup table entry--this entry is four bytes for machines
2658 that have 16-bit pointers (e.g. PC's in the small or medium model). */
2660 typedef struct inflate_huft_s inflate_huft;
2662 struct inflate_huft_s {
2665 Byte Exop; /* number of extra bits or operation */
2666 Byte Bits; /* number of bits in this code or subcode */
2668 uInt pad; /* pad structure to a power of 2 (4 bytes for */
2669 } word; /* 16-bit, 8 bytes for 32-bit int's) */
2670 uInt base; /* literal, length base, distance base,
2674 /* Maximum size of dynamic tree. The maximum found in a long but non-
2675 exhaustive search was 1004 huft structures (850 for length/literals
2676 and 154 for distances, the latter actually the result of an
2677 exhaustive search). The actual maximum is not known, but the
2678 value below is more than safe. */
2681 extern int inflate_trees_bits OF( (
2682 uInt *, /* 19 code lengths */
2683 uInt *, /* bits tree desired/actual depth */
2684 inflate_huft * *, /* bits tree result */
2685 inflate_huft *, /* space for trees */
2686 z_streamp ) ); /* for messages */
2688 extern int inflate_trees_dynamic OF( (
2689 uInt, /* number of literal/length codes */
2690 uInt, /* number of distance codes */
2691 uInt *, /* that many (total) code lengths */
2692 uInt *, /* literal desired/actual bit depth */
2693 uInt *, /* distance desired/actual bit depth */
2694 inflate_huft * *, /* literal/length tree result */
2695 inflate_huft * *, /* distance tree result */
2696 inflate_huft *, /* space for trees */
2697 z_streamp ) ); /* for messages */
2699 extern int inflate_trees_fixed OF( (
2700 uInt *, /* literal desired/actual bit depth */
2701 uInt *, /* distance desired/actual bit depth */
2702 inflate_huft * *, /* literal/length tree result */
2703 inflate_huft * *, /* distance tree result */
2704 z_streamp ) ); /* for memory allocation */
2707 /* infcodes.h -- header to use infcodes.c
2708 * Copyright (C) 1995-1998 Mark Adler
2709 * For conditions of distribution and use, see copyright notice in zlib.h
2712 /* WARNING: this file should *not* be used by applications. It is
2713 part of the implementation of the compression library and is
2714 subject to change. Applications should only use zlib.h.
2717 struct inflate_codes_state;
2718 typedef struct inflate_codes_state inflate_codes_statef;
2720 extern inflate_codes_statef *inflate_codes_new OF( (
2722 inflate_huft *, inflate_huft *,
2725 extern int inflate_codes OF( (
2726 inflate_blocks_statef *,
2730 extern void inflate_codes_free OF( (
2731 inflate_codes_statef *,
2734 /* infutil.h -- types and macros common to blocks and codes
2735 * Copyright (C) 1995-1998 Mark Adler
2736 * For conditions of distribution and use, see copyright notice in zlib.h
2739 /* WARNING: this file should *not* be used by applications. It is
2740 part of the implementation of the compression library and is
2741 subject to change. Applications should only use zlib.h.
2748 TYPE, /* get type bits (3, including end bit) */
2749 LENS, /* get lengths for stored */
2750 STORED, /* processing stored block */
2751 TABLE, /* get table lengths */
2752 BTREE, /* get bit lengths tree for a dynamic block */
2753 DTREE, /* get length, distance trees for a dynamic block */
2754 CODES, /* processing fixed or dynamic block */
2755 DRY, /* output remaining window bytes */
2756 DONE, /* finished last block, done */
2758 } /* got a data error--stuck here */
2761 /* inflate blocks semi-private state */
2762 struct inflate_blocks_state {
2765 inflate_block_mode mode; /* current inflate_block mode */
2767 /* mode dependent information */
2769 uInt left; /* if STORED, bytes left to copy */
2771 uInt table; /* table lengths (14 bits) */
2772 uInt index; /* index into blens (or border) */
2773 uInt *blens; /* bit lengths of codes */
2774 uInt bb; /* bit length tree depth */
2775 inflate_huft *tb; /* bit length decoding tree */
2776 } trees; /* if DTREE, decoding info for trees */
2778 inflate_codes_statef
2780 } decode; /* if CODES, current state */
2781 } sub; /* submode */
2782 uInt last; /* true if this block is the last block */
2784 /* mode independent information */
2785 uInt bitk; /* bits in bit buffer */
2786 uLong bitb; /* bit buffer */
2787 inflate_huft *hufts; /* single malloc for tree space */
2788 Byte *window; /* sliding window */
2789 Byte *end; /* one byte after sliding window */
2790 Byte *read; /* window read pointer */
2791 Byte *write; /* window write pointer */
2792 check_func checkfn; /* check function */
2793 uLong check; /* check on output */
2798 /* defines for inflate input/output */
2799 /* update pointers and return */
2800 #define UPDBITS {s->bitb = b; s->bitk = k; }
2801 #define UPDIN {z->avail_in = n; z->total_in += p - z->next_in; z->next_in = p; }
2802 #define UPDOUT {s->write = q; }
2803 #define UPDATE {UPDBITS UPDIN UPDOUT}
2804 #define LEAVE {UPDATE return inflate_flush( s,z,r ); }
2805 /* get bytes and bits */
2806 #define LOADIN {p = z->next_in; n = z->avail_in; b = s->bitb; k = s->bitk; }
2807 #define NEEDBYTE {if ( n ) {r = Z_OK; }else LEAVE}
2808 #define NEXTBYTE ( n--,*p++ )
2809 #define NEEDBITS( j ) {while ( k < ( j ) ) {NEEDBYTE; b |= ( (uLong)NEXTBYTE ) << k; k += 8; }}
2810 #define DUMPBITS( j ) {b >>= ( j ); k -= ( j ); }
2812 #define WAVAIL (uInt)( q < s->read ? s->read - q - 1 : s->end - q )
2813 #define LOADOUT {q = s->write; m = (uInt)WAVAIL; }
2814 #define WRAP {if ( q == s->end && s->read != s->window ) {q = s->window; m = (uInt)WAVAIL; }}
2815 #define FLUSH {UPDOUT r = inflate_flush( s,z,r ); LOADOUT}
2816 #define NEEDOUT {if ( m == 0 ) {WRAP if ( m == 0 ) {FLUSH WRAP if ( m == 0 ) {LEAVE}} r = Z_OK; }}
2817 #define OUTBYTE( a ) {*q++ = (Byte)( a ); m--; }
2818 /* load static pointers */
2819 #define LOAD {LOADIN LOADOUT}
2821 /* masks for lower bits (size given to avoid silly warnings with Visual C++) */
2822 extern uInt inflate_mask[17];
2824 /* copy as much as possible from the sliding window to the output area */
2825 extern int inflate_flush OF( (
2826 inflate_blocks_statef *,
2834 Notes beyond the 1.93a appnote.txt:
2836 1. Distance pointers never point before the beginning of the output
2838 2. Distance pointers can point back across blocks, up to 32k away.
2839 3. There is an implied maximum of 7 bits for the bit length table and
2840 15 bits for the actual data.
2841 4. If only one code exists, then it is encoded using one bit. (Zero
2842 would be more efficient, but perhaps a little confusing.) If two
2843 codes exist, they are coded using one bit each (0 and 1).
2844 5. There is no way of sending zero distance codes--a dummy must be
2845 sent if there are none. (History: a pre 2.0 version of PKZIP would
2846 store blocks with no distance codes, but this was discovered to be
2847 too harsh a criterion.) Valid only for 1.93a. 2.04c does allow
2848 zero distance codes, which is sent as one code of zero bits in
2850 6. There are up to 286 literal/length codes. Code 256 represents the
2851 end-of-block. Note however that the static length tree defines
2852 288 codes just to fill out the Huffman codes. Codes 286 and 287
2853 cannot be used though, since there is no length base or extra bits
2854 defined for them. Similarily, there are up to 30 distance codes.
2855 However, static trees define 32 codes (all 5 bits) to fill out the
2856 Huffman codes, but the last two had better not show up in the data.
2857 7. Unzip can check dynamic Huffman blocks for complete code sets.
2858 The exception is that a single code would not be complete (see #4).
2859 8. The five bits following the block type is really the number of
2860 literal codes sent minus 257.
2861 9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
2862 (1+6+6). Therefore, to output three times the length, you output
2863 three codes (1+1+1), whereas to output four times the same length,
2864 you only need two codes (1+3). Hmm.
2865 10. In the tree reconstruction algorithm, Code = Code + Increment
2866 only if BitLength(i) is not zero. (Pretty obvious.)
2867 11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19)
2868 12. Note: length code 284 can represent 227-258, but length code 285
2869 really is 258. The last length deserves its own, short code
2870 since it gets used a lot in very redundant files. The length
2871 258 is special since 258 - 3 (the min match length) is 255.
2872 13. The literal/length and distance code bit lengths are read as a
2873 single stream of lengths. It is possible (and advantageous) for
2874 a repeat code (16, 17, or 18) to go across the boundary between
2875 the two sets of lengths.
2879 void inflate_blocks_reset( inflate_blocks_statef *s, z_streamp z, uLong *c ){
2880 if ( c != Z_NULL ) {
2883 if ( s->mode == BTREE || s->mode == DTREE ) {
2884 ZFREE( z, s->sub.trees.blens );
2886 if ( s->mode == CODES ) {
2887 inflate_codes_free( s->sub.decode.codes, z );
2892 s->read = s->write = s->window;
2893 if ( s->checkfn != Z_NULL ) {
2894 z->adler = s->check = ( *s->checkfn )( 0L, (const Byte *)Z_NULL, 0 );
2896 Tracev( ( "inflate: blocks reset\n" ) );
2900 inflate_blocks_statef *inflate_blocks_new( z_streamp z, check_func c, uInt w ){
2901 inflate_blocks_statef *s;
2903 if ( ( s = (inflate_blocks_statef *)ZALLOC
2904 ( z,1,sizeof( struct inflate_blocks_state ) ) ) == Z_NULL ) {
2908 (inflate_huft *)ZALLOC( z, sizeof( inflate_huft ), MANY ) ) == Z_NULL ) {
2912 if ( ( s->window = (Byte *)ZALLOC( z, 1, w ) ) == Z_NULL ) {
2913 ZFREE( z, s->hufts );
2917 s->end = s->window + w;
2920 Tracev( ( "inflate: blocks allocated\n" ) );
2921 inflate_blocks_reset( s, z, Z_NULL );
2926 int inflate_blocks( inflate_blocks_statef *s, z_streamp z, int r ){
2927 uInt t; /* temporary storage */
2928 uLong b; /* bit buffer */
2929 uInt k; /* bits in bit buffer */
2930 Byte *p; /* input data pointer */
2931 uInt n; /* bytes available there */
2932 Byte *q; /* output window write pointer */
2933 uInt m; /* bytes to end of window or read pointer */
2935 /* copy input/output information to locals (UPDATE macro restores) */
2938 /* process input based on current state */
2939 while ( 1 ) switch ( s->mode )
2947 case 0: /* stored */
2948 Tracev( ( "inflate: stored block%s\n",
2949 s->last ? " (last)" : "" ) );
2951 t = k & 7; /* go to byte boundary */
2953 s->mode = LENS; /* get length of stored block */
2956 Tracev( ( "inflate: fixed codes block%s\n",
2957 s->last ? " (last)" : "" ) );
2960 inflate_huft *tl, *td;
2962 inflate_trees_fixed( &bl, &bd, &tl, &td, z );
2963 s->sub.decode.codes = inflate_codes_new( bl, bd, tl, td, z );
2964 if ( s->sub.decode.codes == Z_NULL ) {
2972 case 2: /* dynamic */
2973 Tracev( ( "inflate: dynamic codes block%s\n",
2974 s->last ? " (last)" : "" ) );
2978 case 3: /* illegal */
2981 z->msg = (char*)"invalid block type";
2988 if ( ( ( ( ~b ) >> 16 ) & 0xffff ) != ( b & 0xffff ) ) {
2990 z->msg = (char*)"invalid stored block lengths";
2994 s->sub.left = (uInt)b & 0xffff;
2995 b = k = 0; /* dump bits */
2996 Tracev( ( "inflate: stored length %u\n", s->sub.left ) );
2997 s->mode = s->sub.left ? STORED : ( s->last ? DRY : TYPE );
3014 if ( ( s->sub.left -= t ) != 0 ) {
3017 Tracev( ( "inflate: stored end, %lu total out\n",
3018 z->total_out + ( q >= s->read ? q - s->read :
3019 ( s->end - s->read ) + ( q - s->window ) ) ) );
3020 s->mode = s->last ? DRY : TYPE;
3024 s->sub.trees.table = t = (uInt)b & 0x3fff;
3025 #ifndef PKZIP_BUG_WORKAROUND
3026 if ( ( t & 0x1f ) > 29 || ( ( t >> 5 ) & 0x1f ) > 29 ) {
3028 z->msg = (char*)"too many length or distance symbols";
3033 t = 258 + ( t & 0x1f ) + ( ( t >> 5 ) & 0x1f );
3034 if ( ( s->sub.trees.blens = (uInt*)ZALLOC( z, t, sizeof( uInt ) ) ) == Z_NULL ) {
3039 s->sub.trees.index = 0;
3040 Tracev( ( "inflate: table sizes ok\n" ) );
3043 while ( s->sub.trees.index < 4 + ( s->sub.trees.table >> 10 ) )
3046 s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
3049 while ( s->sub.trees.index < 19 )
3050 s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
3051 s->sub.trees.bb = 7;
3052 t = inflate_trees_bits( s->sub.trees.blens, &s->sub.trees.bb,
3053 &s->sub.trees.tb, s->hufts, z );
3055 ZFREE( z, s->sub.trees.blens );
3057 if ( r == Z_DATA_ERROR ) {
3062 s->sub.trees.index = 0;
3063 Tracev( ( "inflate: bits tree ok\n" ) );
3066 while ( t = s->sub.trees.table,
3067 s->sub.trees.index < 258 + ( t & 0x1f ) + ( ( t >> 5 ) & 0x1f ) )
3072 t = s->sub.trees.bb;
3074 h = s->sub.trees.tb + ( (uInt)b & inflate_mask[t] );
3079 s->sub.trees.blens[s->sub.trees.index++] = c;
3081 else /* c == 16..18 */
3083 i = c == 18 ? 7 : c - 14;
3084 j = c == 18 ? 11 : 3;
3087 j += (uInt)b & inflate_mask[i];
3089 i = s->sub.trees.index;
3090 t = s->sub.trees.table;
3091 if ( i + j > 258 + ( t & 0x1f ) + ( ( t >> 5 ) & 0x1f ) ||
3092 ( c == 16 && i < 1 ) ) {
3093 ZFREE( z, s->sub.trees.blens );
3095 z->msg = (char*)"invalid bit length repeat";
3099 c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
3101 s->sub.trees.blens[i++] = c;
3103 s->sub.trees.index = i;
3106 s->sub.trees.tb = Z_NULL;
3109 inflate_huft *tl, *td;
3110 inflate_codes_statef *c;
3112 bl = 9; /* must be <= 9 for lookahead assumptions */
3113 bd = 6; /* must be <= 9 for lookahead assumptions */
3114 t = s->sub.trees.table;
3115 t = inflate_trees_dynamic( 257 + ( t & 0x1f ), 1 + ( ( t >> 5 ) & 0x1f ),
3116 s->sub.trees.blens, &bl, &bd, &tl, &td,
3118 ZFREE( z, s->sub.trees.blens );
3120 if ( t == (uInt)Z_DATA_ERROR ) {
3126 Tracev( ( "inflate: trees ok\n" ) );
3127 if ( ( c = inflate_codes_new( bl, bd, tl, td, z ) ) == Z_NULL ) {
3131 s->sub.decode.codes = c;
3136 if ( ( r = inflate_codes( s, z, r ) ) != Z_STREAM_END ) {
3137 return inflate_flush( s, z, r );
3140 inflate_codes_free( s->sub.decode.codes, z );
3142 Tracev( ( "inflate: codes end, %lu total out\n",
3143 z->total_out + ( q >= s->read ? q - s->read :
3144 ( s->end - s->read ) + ( q - s->window ) ) ) );
3152 if ( s->read != s->write ) {
3169 int inflate_blocks_free( inflate_blocks_statef *s, z_streamp z ){
3170 inflate_blocks_reset( s, z, Z_NULL );
3171 ZFREE( z, s->window );
3172 ZFREE( z, s->hufts );
3174 Tracev( ( "inflate: blocks freed\n" ) );
3179 void inflate_set_dictionary( inflate_blocks_statef *s, const Byte *d, uInt n ){
3180 zmemcpy( s->window, d, n );
3181 s->read = s->write = s->window + n;
3185 /* Returns true if inflate is currently at the end of a block generated
3186 * by Z_SYNC_FLUSH or Z_FULL_FLUSH.
3187 * IN assertion: s != Z_NULL
3189 int inflate_blocks_sync_point( inflate_blocks_statef *s ){
3190 return s->mode == LENS;
3193 /* And'ing with mask[n] masks the lower n bits */
3194 uInt inflate_mask[17] = {
3196 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
3197 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
3200 /* copy as much as possible from the sliding window to the output area */
3201 int inflate_flush( inflate_blocks_statef *s, z_streamp z, int r ){
3206 /* static copies of source and destination pointers */
3210 /* compute number of bytes to copy as as end of window */
3211 n = (uInt)( ( q <= s->write ? s->write : s->end ) - q );
3212 if ( n > z->avail_out ) {
3215 if ( n && r == Z_BUF_ERROR ) {
3219 /* update counters */
3223 /* update check information */
3224 if ( s->checkfn != Z_NULL ) {
3225 z->adler = s->check = ( *s->checkfn )( s->check, q, n );
3228 /* copy as as end of window */
3233 /* see if more to copy at beginning of window */
3234 if ( q == s->end ) {
3237 if ( s->write == s->end ) {
3238 s->write = s->window;
3241 /* compute bytes to copy */
3242 n = (uInt)( s->write - q );
3243 if ( n > z->avail_out ) {
3246 if ( n && r == Z_BUF_ERROR ) {
3250 /* update counters */
3254 /* update check information */
3255 if ( s->checkfn != Z_NULL ) {
3256 z->adler = s->check = ( *s->checkfn )( s->check, q, n );
3265 /* update pointers */
3273 /* inftrees.c -- generate Huffman trees for efficient decoding
3274 * Copyright (C) 1995-1998 Mark Adler
3275 * For conditions of distribution and use, see copyright notice in zlib.h
3278 const char inflate_copyright[] =
3279 " inflate 1.1.3 Copyright 1995-1998 Mark Adler ";
3281 If you use the zlib library in a product, an acknowledgment is welcome
3282 in the documentation of your product. If for some reason you cannot
3283 include such an acknowledgment, I would appreciate that you keep this
3284 copyright string in the executable of your product.
3287 /* simplify the use of the inflate_huft type with some defines */
3288 #define exop word.what.Exop
3289 #define bits word.what.Bits
3292 static int huft_build OF( (
3293 uInt *, /* code lengths in bits */
3294 uInt, /* number of codes */
3295 uInt, /* number of "simple" codes */
3296 const uInt *, /* list of base values for non-simple codes */
3297 const uInt *, /* list of extra bits for non-simple codes */
3298 inflate_huft * *, /* result: starting table */
3299 uInt *, /* maximum lookup bits (returns actual) */
3300 inflate_huft *, /* space for trees */
3301 uInt *, /* hufts used in space */
3302 uInt * ) ); /* space for values */
3304 /* Tables for deflate from PKZIP's appnote.txt. */
3305 static const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
3306 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
3307 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
3309 /* see note #13 above about 258 */
3310 static const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
3311 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
3312 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112
3313 }; /* 112==invalid */
3314 static const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
3315 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
3316 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
3317 8193, 12289, 16385, 24577
3319 static const uInt cpdext[30] = { /* Extra bits for distance codes */
3320 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
3321 7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
3326 Huffman code decoding is performed using a multi-level table lookup.
3327 The fastest way to decode is to simply build a lookup table whose
3328 size is determined by the longest code. However, the time it takes
3329 to build this table can also be a factor if the data being decoded
3330 is not very long. The most common codes are necessarily the
3331 shortest codes, so those codes dominate the decoding time, and hence
3332 the speed. The idea is you can have a shorter table that decodes the
3333 shorter, more probable codes, and then point to subsidiary tables for
3334 the longer codes. The time it costs to decode the longer codes is
3335 then traded against the time it takes to make longer tables.
3337 This results of this trade are in the variables lbits and dbits
3338 below. lbits is the number of bits the first level table for literal/
3339 length codes can decode in one step, and dbits is the same thing for
3340 the distance codes. Subsequent tables are also less than or equal to
3341 those sizes. These values may be adjusted either when all of the
3342 codes are shorter than that, in which case the longest code length in
3343 bits is used, or when the shortest code is *longer* than the requested
3344 table size, in which case the length of the shortest code in bits is
3347 There are two different values for the two tables, since they code a
3348 different number of possibilities each. The literal/length table
3349 codes 286 possible values, or in a flat code, a little over eight
3350 bits. The distance table codes 30 possible values, or a little less
3351 than five bits, flat. The optimum values for speed end up being
3352 about one bit more than those, so lbits is 8+1 and dbits is 5+1.
3353 The optimum values may differ though from machine to machine, and
3354 possibly even between compilers. Your mileage may vary.
3358 /* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
3359 #define BMAX 15 /* maximum bit length of any code */
3361 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 ){
3362 //uInt *b; /* code lengths in bits (all assumed <= BMAX) */
3363 //uInt n; /* number of codes (assumed <= 288) */
3364 //uInt s; /* number of simple-valued codes (0..s-1) */
3365 //const uInt *d; /* list of base values for non-simple codes */
3366 //const uInt *e; /* list of extra bits for non-simple codes */
3367 //inflate_huft ** t; /* result: starting table */
3368 //uInt *m; /* maximum lookup bits, returns actual */
3369 //inflate_huft *hp; /* space for trees */
3370 //uInt *hn; /* hufts used in space */
3371 //uInt *v; /* working area: values in order of bit length */
3372 /* Given a list of code lengths and a maximum table size, make a set of
3373 tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
3374 if the given code set is incomplete (the tables are still built in this
3375 case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
3376 lengths), or Z_MEM_ERROR if not enough memory. */
3378 uInt a; /* counter for codes of length k */
3379 uInt c[BMAX + 1]; /* bit length count table */
3380 uInt f; /* i repeats in table every f entries */
3381 int g; /* maximum code length */
3382 int h; /* table level */
3383 register uInt i; /* counter, current code */
3384 register uInt j; /* counter */
3385 register int k; /* number of bits in current code */
3386 int l; /* bits per table (returned in m) */
3387 uInt mask; /* (1 << w) - 1, to avoid cc -O bug on HP */
3388 register uInt *p; /* pointer into c[], b[], or v[] */
3389 inflate_huft *q; /* points to current table */
3390 struct inflate_huft_s r; /* table entry for structure assignment */
3391 inflate_huft *u[BMAX]; /* table stack */
3392 register int w; /* bits before this table == (l * h) */
3393 uInt x[BMAX + 1]; /* bit offsets, then code stack */
3394 uInt *xp; /* pointer into x */
3395 int y; /* number of dummy codes added */
3396 uInt z; /* number of entries in current table */
3399 /* Generate counts for each bit length */
3401 #define C0 *p++ = 0;
3402 #define C2 C0 C0 C0 C0
3403 #define C4 C2 C2 C2 C2
3404 C4 /* clear c[]--assume BMAX+1 is 16 */
3407 c[*p++]++; /* assume all entries <= BMAX */
3409 if ( c[0] == n ) { /* null input--all zero length codes */
3410 *t = (inflate_huft *)Z_NULL;
3416 /* Find minimum and maximum length, bound *m by those */
3418 for ( j = 1; j <= BMAX; j++ )
3422 k = j; /* minimum code length */
3423 if ( (uInt)l < j ) {
3426 for ( i = BMAX; i; i-- )
3430 g = i; /* maximum code length */
3431 if ( (uInt)l > i ) {
3437 /* Adjust last length count to fill out codes, if needed */
3438 for ( y = 1 << j; j < i; j++, y <<= 1 )
3439 if ( ( y -= c[j] ) < 0 ) {
3440 return Z_DATA_ERROR;
3442 if ( ( y -= c[i] ) < 0 ) {
3443 return Z_DATA_ERROR;
3448 /* Generate starting offsets into the value table for each length */
3450 p = c + 1; xp = x + 2;
3451 while ( --i ) { /* note that i == g from above */
3452 *xp++ = ( j += *p++ );
3456 /* Make a table of values in order of bit lengths */
3459 if ( ( j = *p++ ) != 0 ) {
3462 } while ( ++i < n );
3463 n = x[g]; /* set n to length of v */
3466 /* Generate the Huffman codes and for each, make the table entries */
3467 x[0] = i = 0; /* first Huffman code is zero */
3468 p = v; /* grab values in bit order */
3469 h = -1; /* no tables yet--level -1 */
3470 w = -l; /* bits decoded == (l * h) */
3471 u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */
3472 q = (inflate_huft *)Z_NULL; /* ditto */
3475 /* go through the bit lengths (k already is bits in shortest code) */
3476 for (; k <= g; k++ )
3481 /* here i is the Huffman code of length k bits for value *p */
3482 /* make tables up to required level */
3486 w += l; /* previous table always l bits */
3488 /* compute minimum size table less than or equal to l bits */
3490 z = z > (uInt)l ? l : z; /* table size upper limit */
3491 if ( ( f = 1 << ( j = k - w ) ) > a + 1 ) { /* try a k-w bit table */
3492 /* too few codes for k-w bit table */
3493 f -= a + 1; /* deduct codes from patterns left */
3496 while ( ++j < z ) /* try smaller tables up to z bits */
3498 if ( ( f <<= 1 ) <= *++xp ) {
3499 break; /* enough codes to use up j bits */
3501 f -= *xp; /* else deduct codes from patterns */
3505 z = 1 << j; /* table entries for j-bit table */
3507 /* allocate new table */
3508 if ( *hn + z > MANY ) { /* (note: doesn't matter for fixed) */
3509 return Z_MEM_ERROR; /* not enough memory */
3511 u[h] = q = hp + *hn;
3514 /* connect to last table, if there is one */
3516 x[h] = i; /* save pattern for backing up */
3517 r.bits = (Byte)l; /* bits to dump before this table */
3518 r.exop = (Byte)j; /* bits in this table */
3520 r.base = (uInt)( q - u[h - 1] - j ); /* offset to this table */
3521 u[h - 1][j] = r; /* connect to last table */
3524 *t = q; /* first table is returned result */
3528 /* set up table entry in r */
3529 r.bits = (Byte)( k - w );
3531 r.exop = 128 + 64; /* out of values--invalid code */
3533 else if ( *p < s ) {
3534 r.exop = (Byte)( *p < 256 ? 0 : 32 + 64 ); /* 256 is end-of-block */
3535 r.base = *p++; /* simple code is just the value */
3539 r.exop = (Byte)( e[*p - s] + 16 + 64 ); /* non-simple--look up in lists */
3540 r.base = d[*p++ - s];
3543 /* fill code-like entries with r */
3545 for ( j = i >> w; j < z; j += f )
3548 /* backwards increment the k-bit code i */
3549 for ( j = 1 << ( k - 1 ); i &j; j >>= 1 )
3553 /* backup over finished tables */
3554 mask = ( 1 << w ) - 1; /* needed on HP, cc -O bug */
3555 while ( ( i & mask ) != x[h] )
3557 h--; /* don't need to update q */
3559 mask = ( 1 << w ) - 1;
3565 /* Return Z_BUF_ERROR if we were given an incomplete table */
3566 return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
3570 int inflate_trees_bits( uInt *c, uInt *bb, inflate_huft * *tb, inflate_huft *hp, z_streamp z ){
3571 //uInt *c; /* 19 code lengths */
3572 //uInt *bb; /* bits tree desired/actual depth */
3573 //inflate_huft * *tb; /* bits tree result */
3574 //inflate_huft *hp; /* space for trees */
3575 //z_streamp z; /* for messages */
3577 uInt hn = 0; /* hufts used in space */
3578 uInt *v; /* work area for huft_build */
3580 if ( ( v = (uInt*)ZALLOC( z, 19, sizeof( uInt ) ) ) == Z_NULL ) {
3583 r = huft_build( c, 19, 19, (uInt*)Z_NULL, (uInt*)Z_NULL,
3584 tb, bb, hp, &hn, v );
3585 if ( r == Z_DATA_ERROR ) {
3586 z->msg = (char*)"oversubscribed dynamic bit lengths tree";
3588 else if ( r == Z_BUF_ERROR || *bb == 0 ) {
3589 z->msg = (char*)"incomplete dynamic bit lengths tree";
3597 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 ){
3598 //uInt nl; /* number of literal/length codes */
3599 //uInt nd; /* number of distance codes */
3600 //uInt *c; /* that many (total) code lengths */
3601 //uInt *bl; /* literal desired/actual bit depth */
3602 //uInt *bd; /* distance desired/actual bit depth */
3603 //inflate_huft * *tl; /* literal/length tree result */
3604 //inflate_huft * *td; /* distance tree result */
3605 //inflate_huft *hp; /* space for trees */
3606 //z_streamp z; /* for messages */
3608 uInt hn = 0; /* hufts used in space */
3609 uInt *v; /* work area for huft_build */
3611 /* allocate work area */
3612 if ( ( v = (uInt*)ZALLOC( z, 288, sizeof( uInt ) ) ) == Z_NULL ) {
3616 /* build literal/length tree */
3617 r = huft_build( c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v );
3618 if ( r != Z_OK || *bl == 0 ) {
3619 if ( r == Z_DATA_ERROR ) {
3620 z->msg = (char*)"oversubscribed literal/length tree";
3622 else if ( r != Z_MEM_ERROR ) {
3623 z->msg = (char*)"incomplete literal/length tree";
3630 /* build distance tree */
3631 r = huft_build( c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v );
3632 if ( r != Z_OK || ( *bd == 0 && nl > 257 ) ) {
3633 if ( r == Z_DATA_ERROR ) {
3634 z->msg = (char*)"oversubscribed distance tree";
3636 else if ( r == Z_BUF_ERROR ) {
3637 #ifdef PKZIP_BUG_WORKAROUND
3641 z->msg = (char*)"incomplete distance tree";
3644 else if ( r != Z_MEM_ERROR ) {
3645 z->msg = (char*)"empty distance tree with lengths";
3658 /* inffixed.h -- table for decoding fixed codes
3659 * Generated automatically by the maketree.c program
3662 /* WARNING: this file should *not* be used by applications. It is
3663 part of the implementation of the compression library and is
3664 subject to change. Applications should only use zlib.h.
3667 static uInt fixed_bl = 9;
3668 static uInt fixed_bd = 5;
3669 static inflate_huft fixed_tl[] = {
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}},192},
3672 {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},160},
3673 {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},224},
3674 {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},144},
3675 {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},208},
3676 {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},176},
3677 {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},240},
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}},200},
3680 {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},168},
3681 {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},232},
3682 {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},152},
3683 {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},216},
3684 {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},184},
3685 {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},248},
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}},196},
3688 {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},164},
3689 {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},228},
3690 {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},148},
3691 {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},212},
3692 {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},180},
3693 {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},244},
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}},204},
3696 {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},172},
3697 {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},236},
3698 {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},156},
3699 {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},220},
3700 {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},188},
3701 {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},252},
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}},194},
3704 {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},162},
3705 {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},226},
3706 {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},146},
3707 {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},210},
3708 {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},178},
3709 {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},242},
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}},202},
3712 {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},170},
3713 {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},234},
3714 {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},154},
3715 {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},218},
3716 {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},186},
3717 {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},250},
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}},198},
3720 {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},166},
3721 {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},230},
3722 {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},150},
3723 {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},214},
3724 {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},182},
3725 {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},246},
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}},206},
3728 {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},174},
3729 {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},238},
3730 {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},158},
3731 {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},222},
3732 {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},190},
3733 {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},254},
3734 {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
3735 {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},193},
3736 {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},161},
3737 {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},225},
3738 {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},145},
3739 {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},209},
3740 {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},177},
3741 {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},241},
3742 {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
3743 {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},201},
3744 {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},169},
3745 {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},233},
3746 {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},153},
3747 {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},217},
3748 {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},185},
3749 {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},249},
3750 {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
3751 {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},197},
3752 {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},165},
3753 {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},229},
3754 {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},149},
3755 {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},213},
3756 {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},181},
3757 {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},245},
3758 {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
3759 {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},205},
3760 {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},173},
3761 {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},237},
3762 {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},157},
3763 {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},221},
3764 {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},189},
3765 {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},253},
3766 {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
3767 {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},195},
3768 {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},163},
3769 {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},227},
3770 {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},147},
3771 {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},211},
3772 {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},179},
3773 {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},243},
3774 {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
3775 {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},203},
3776 {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},171},
3777 {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},235},
3778 {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},155},
3779 {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},219},
3780 {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},187},
3781 {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},251},
3782 {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
3783 {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},199},
3784 {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},167},
3785 {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},231},
3786 {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},151},
3787 {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},215},
3788 {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},183},
3789 {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},247},
3790 {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
3791 {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},207},
3792 {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},175},
3793 {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},239},
3794 {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},159},
3795 {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},223},
3796 {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},191},
3797 {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},255}
3799 static inflate_huft fixed_td[] = {
3800 {{{80,5}},1}, {{{87,5}},257}, {{{83,5}},17}, {{{91,5}},4097},
3801 {{{81,5}},5}, {{{89,5}},1025}, {{{85,5}},65}, {{{93,5}},16385},
3802 {{{80,5}},3}, {{{88,5}},513}, {{{84,5}},33}, {{{92,5}},8193},
3803 {{{82,5}},9}, {{{90,5}},2049}, {{{86,5}},129}, {{{192,5}},24577},
3804 {{{80,5}},2}, {{{87,5}},385}, {{{83,5}},25}, {{{91,5}},6145},
3805 {{{81,5}},7}, {{{89,5}},1537}, {{{85,5}},97}, {{{93,5}},24577},
3806 {{{80,5}},4}, {{{88,5}},769}, {{{84,5}},49}, {{{92,5}},12289},
3807 {{{82,5}},13}, {{{90,5}},3073}, {{{86,5}},193}, {{{192,5}},24577}
3810 int inflate_trees_fixed( uInt *bl, uInt *bd, inflate_huft * *tl, inflate_huft * *td, z_streamp z ){
3811 //uInt *bl; /* literal desired/actual bit depth */
3812 //uInt *bd; /* distance desired/actual bit depth */
3813 //inflate_huft * *tl; /* literal/length tree result */
3814 //inflate_huft * *td; /* distance tree result */
3815 //z_streamp z; /* for memory allocation */
3823 /* simplify the use of the inflate_huft type with some defines */
3824 #define exop word.what.Exop
3825 #define bits word.what.Bits
3827 /* macros for bit input with no checking and for returning unused bytes */
3828 #define GRABBITS( j ) {while ( k < ( j ) ) {b |= ( (uLong)NEXTBYTE ) << k; k += 8; }}
3829 #define UNGRAB {c = z->avail_in - n; c = ( k >> 3 ) < c ? k >> 3 : c; n += c; p -= c; k -= c << 3; }
3831 /* Called with number of bytes left to write in window at least 258
3832 (the maximum string length) and number of input bytes available
3833 at least ten. The ten bytes are six bytes for the longest length/
3834 distance pair plus four bytes for overloading the bit buffer. */
3836 int inflate_fast( uInt bl, uInt bd, inflate_huft *tl, inflate_huft *td, inflate_blocks_statef *s, z_streamp z ){
3837 inflate_huft *t; /* temporary pointer */
3838 uInt e; /* extra bits or operation */
3839 uLong b; /* bit buffer */
3840 uInt k; /* bits in bit buffer */
3841 Byte *p; /* input data pointer */
3842 uInt n; /* bytes available there */
3843 Byte *q; /* output window write pointer */
3844 uInt m; /* bytes to end of window or read pointer */
3845 uInt ml; /* mask for literal/length tree */
3846 uInt md; /* mask for distance tree */
3847 uInt c; /* bytes to copy */
3848 uInt d; /* distance back to copy from */
3849 Byte *r; /* copy source pointer */
3851 /* load input, output, bit values */
3854 /* initialize masks */
3855 ml = inflate_mask[bl];
3856 md = inflate_mask[bd];
3858 /* do until not enough input or output space for fast loop */
3859 do { /* assume called with m >= 258 && n >= 10 */
3860 /* get literal/length code */
3861 GRABBITS( 20 ) /* max bits for literal/length code */
3862 if ( ( e = ( t = tl + ( (uInt)b & ml ) )->exop ) == 0 ) {
3864 Tracevv( ( t->base >= 0x20 && t->base < 0x7f ?
3865 "inflate: * literal '%c'\n" :
3866 "inflate: * literal 0x%02x\n", t->base ) );
3867 *q++ = (Byte)t->base;
3874 /* get extra bits for length */
3876 c = t->base + ( (uInt)b & inflate_mask[e] );
3878 Tracevv( ( "inflate: * length %u\n", c ) );
3880 /* decode distance base of block to copy */
3881 GRABBITS( 15 ); /* max bits for distance code */
3882 e = ( t = td + ( (uInt)b & md ) )->exop;
3886 /* get extra bits to add to distance base */
3888 GRABBITS( e ) /* get extra bits (up to 13) */
3889 d = t->base + ( (uInt)b & inflate_mask[e] );
3891 Tracevv( ( "inflate: * distance %u\n", d ) );
3895 if ( (uInt)( q - s->window ) >= d ) { /* offset before dest */
3898 *q++ = *r++; c--; /* minimum count is three, */
3899 *q++ = *r++; c--; /* so unroll loop a little */
3901 else /* else offset after destination */
3903 e = d - (uInt)( q - s->window ); /* bytes from offset to end */
3904 r = s->end - e; /* pointer to offset */
3905 if ( c > e ) { /* if source crosses, */
3906 c -= e; /* copy to end of window */
3910 r = s->window; /* copy rest from start of window */
3913 do { /* copy all or what's left */
3918 else if ( ( e & 64 ) == 0 ) {
3920 e = ( t += ( (uInt)b & inflate_mask[e] ) )->exop;
3924 z->msg = (char*)"invalid distance code";
3927 return Z_DATA_ERROR;
3932 if ( ( e & 64 ) == 0 ) {
3934 if ( ( e = ( t += ( (uInt)b & inflate_mask[e] ) )->exop ) == 0 ) {
3936 Tracevv( ( t->base >= 0x20 && t->base < 0x7f ?
3937 "inflate: * literal '%c'\n" :
3938 "inflate: * literal 0x%02x\n", t->base ) );
3939 *q++ = (Byte)t->base;
3944 else if ( e & 32 ) {
3945 Tracevv( ( "inflate: * end of block\n" ) );
3948 return Z_STREAM_END;
3952 z->msg = (char*)"invalid literal/length code";
3955 return Z_DATA_ERROR;
3958 } while ( m >= 258 && n >= 10 );
3960 /* not enough input or output--restore pointers and return */
3966 /* infcodes.c -- process literals and length/distance pairs
3967 * Copyright (C) 1995-1998 Mark Adler
3968 * For conditions of distribution and use, see copyright notice in zlib.h
3971 /* simplify the use of the inflate_huft type with some defines */
3972 #define exop word.what.Exop
3973 #define bits word.what.Bits
3975 typedef enum { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
3976 START, /* x: set up for LEN */
3977 LEN, /* i: get length/literal/eob next */
3978 LENEXT, /* i: getting length extra (have base) */
3979 DIST, /* i: get distance next */
3980 DISTEXT, /* i: getting distance extra */
3981 COPY, /* o: copying bytes in window, waiting for space */
3982 LIT, /* o: got literal, waiting for output space */
3983 WASH, /* o: got eob, possibly still output waiting */
3984 END, /* x: got eob and all data flushed */
3986 } /* x: got error */
3989 /* inflate codes private state */
3990 struct inflate_codes_state {
3993 inflate_codes_mode mode; /* current inflate_codes mode */
3995 /* mode dependent information */
3999 inflate_huft *tree; /* pointer into tree */
4000 uInt need; /* bits needed */
4001 } code; /* if LEN or DIST, where in tree */
4002 uInt lit; /* if LIT, literal */
4004 uInt get; /* bits to get for extra */
4005 uInt dist; /* distance back to copy from */
4006 } copy; /* if EXT or COPY, where and how much */
4007 } sub; /* submode */
4009 /* mode independent information */
4010 Byte lbits; /* ltree bits decoded per branch */
4011 Byte dbits; /* dtree bits decoder per branch */
4012 inflate_huft *ltree; /* literal/length/eob tree */
4013 inflate_huft *dtree; /* distance tree */
4018 inflate_codes_statef *inflate_codes_new( uInt bl, uInt bd, inflate_huft *tl, inflate_huft *td, z_streamp z ){
4019 inflate_codes_statef *c;
4021 if ( ( c = (inflate_codes_statef *)
4022 ZALLOC( z,1,sizeof( struct inflate_codes_state ) ) ) != Z_NULL ) {
4024 c->lbits = (Byte)bl;
4025 c->dbits = (Byte)bd;
4028 Tracev( ( "inflate: codes new\n" ) );
4034 int inflate_codes( inflate_blocks_statef *s, z_streamp z, int r ){
4035 uInt j; /* temporary storage */
4036 inflate_huft *t; /* temporary pointer */
4037 uInt e; /* extra bits or operation */
4038 uLong b; /* bit buffer */
4039 uInt k; /* bits in bit buffer */
4040 Byte *p; /* input data pointer */
4041 uInt n; /* bytes available there */
4042 Byte *q; /* output window write pointer */
4043 uInt m; /* bytes to end of window or read pointer */
4044 Byte *f; /* pointer to copy strings from */
4045 inflate_codes_statef *c = s->sub.decode.codes; /* codes state */
4047 /* copy input/output information to locals (UPDATE macro restores) */
4050 /* process input and output based on current state */
4051 while ( 1 ) switch ( c->mode )
4052 { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
4053 case START: /* x: set up for LEN */
4055 if ( m >= 258 && n >= 10 ) {
4057 r = inflate_fast( c->lbits, c->dbits, c->ltree, c->dtree, s, z );
4060 c->mode = r == Z_STREAM_END ? WASH : BADCODE;
4065 c->sub.code.need = c->lbits;
4066 c->sub.code.tree = c->ltree;
4068 case LEN: /* i: get length/literal/eob next */
4069 j = c->sub.code.need;
4071 t = c->sub.code.tree + ( (uInt)b & inflate_mask[j] );
4073 e = (uInt)( t->exop );
4074 if ( e == 0 ) { /* literal */
4075 c->sub.lit = t->base;
4076 Tracevv( ( t->base >= 0x20 && t->base < 0x7f ?
4077 "inflate: literal '%c'\n" :
4078 "inflate: literal 0x%02x\n", t->base ) );
4082 if ( e & 16 ) { /* length */
4083 c->sub.copy.get = e & 15;
4088 if ( ( e & 64 ) == 0 ) { /* next table */
4089 c->sub.code.need = e;
4090 c->sub.code.tree = t + t->base;
4093 if ( e & 32 ) { /* end of block */
4094 Tracevv( ( "inflate: end of block\n" ) );
4098 c->mode = BADCODE; /* invalid code */
4099 z->msg = (char*)"invalid literal/length code";
4102 case LENEXT: /* i: getting length extra (have base) */
4103 j = c->sub.copy.get;
4105 c->len += (uInt)b & inflate_mask[j];
4107 c->sub.code.need = c->dbits;
4108 c->sub.code.tree = c->dtree;
4109 Tracevv( ( "inflate: length %u\n", c->len ) );
4111 case DIST: /* i: get distance next */
4112 j = c->sub.code.need;
4114 t = c->sub.code.tree + ( (uInt)b & inflate_mask[j] );
4116 e = (uInt)( t->exop );
4117 if ( e & 16 ) { /* distance */
4118 c->sub.copy.get = e & 15;
4119 c->sub.copy.dist = t->base;
4123 if ( ( e & 64 ) == 0 ) { /* next table */
4124 c->sub.code.need = e;
4125 c->sub.code.tree = t + t->base;
4128 c->mode = BADCODE; /* invalid code */
4129 z->msg = (char*)"invalid distance code";
4132 case DISTEXT: /* i: getting distance extra */
4133 j = c->sub.copy.get;
4135 c->sub.copy.dist += (uInt)b & inflate_mask[j];
4137 Tracevv( ( "inflate: distance %u\n", c->sub.copy.dist ) );
4139 case COPY: /* o: copying bytes in window, waiting for space */
4140 #ifndef __TURBOC__ /* Turbo C bug for following expression */
4141 f = (uInt)( q - s->window ) < c->sub.copy.dist ?
4142 s->end - ( c->sub.copy.dist - ( q - s->window ) ) :
4143 q - c->sub.copy.dist;
4145 f = q - c->sub.copy.dist;
4146 if ( (uInt)( q - s->window ) < c->sub.copy.dist ) {
4147 f = s->end - ( c->sub.copy.dist - (uInt)( q - s->window ) );
4154 if ( f == s->end ) {
4161 case LIT: /* o: got literal, waiting for output space */
4163 OUTBYTE( c->sub.lit )
4166 case WASH: /* o: got eob, possibly more output */
4167 if ( k > 7 ) { /* return unused byte, if any */
4168 Assert( k < 16, "inflate_codes grabbed too many bytes" )
4171 p--; /* can always return one */
4174 if ( s->read != s->write ) {
4181 case BADCODE: /* x: got error */
4188 #ifdef NEED_DUMMY_RETURN
4189 return Z_STREAM_ERROR; /* Some dumb compilers complain without this */
4194 void inflate_codes_free( inflate_codes_statef *c, z_streamp z ){
4196 Tracev( ( "inflate: codes free\n" ) );
4199 /* adler32.c -- compute the Adler-32 checksum of a data stream
4200 * Copyright (C) 1995-1998 Mark Adler
4201 * For conditions of distribution and use, see copyright notice in zlib.h
4204 #define BASE 65521L /* largest prime smaller than 65536 */
4206 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
4213 #define DO1( buf,i ) {s1 += buf[i]; s2 += s1; }
4214 #define DO2( buf,i ) DO1( buf,i ); DO1( buf,i + 1 );
4215 #define DO4( buf,i ) DO2( buf,i ); DO2( buf,i + 2 );
4216 #define DO8( buf,i ) DO4( buf,i ); DO4( buf,i + 4 );
4217 #define DO16( buf ) DO8( buf,0 ); DO8( buf,8 );
4219 /* ========================================================================= */
4220 uLong adler32( uLong adler, const Byte *buf, uInt len ){
4221 unsigned long s1 = adler & 0xffff;
4222 unsigned long s2 = ( adler >> 16 ) & 0xffff;
4225 if ( buf == Z_NULL ) {
4230 k = len < NMAX ? len : NMAX;
4246 return ( s2 << 16 ) | s1;
4250 /* infblock.h -- header to use infblock.c
4251 * Copyright (C) 1995-1998 Mark Adler
4252 * For conditions of distribution and use, see copyright notice in zlib.h
4255 /* WARNING: this file should *not* be used by applications. It is
4256 part of the implementation of the compression library and is
4257 subject to change. Applications should only use zlib.h.
4260 extern inflate_blocks_statef * inflate_blocks_new OF( (
4262 check_func c, /* check function */
4263 uInt w ) ); /* window size */
4265 extern int inflate_blocks OF( (
4266 inflate_blocks_statef *,
4268 int ) ); /* initial return code */
4270 extern void inflate_blocks_reset OF( (
4271 inflate_blocks_statef *,
4273 uLong * ) ); /* check value on output */
4275 extern int inflate_blocks_free OF( (
4276 inflate_blocks_statef *,
4279 extern void inflate_set_dictionary OF( (
4280 inflate_blocks_statef * s,
4281 const Byte * d, /* dictionary */
4282 uInt n ) ); /* dictionary length */
4284 extern int inflate_blocks_sync_point OF( (
4285 inflate_blocks_statef * s ) );
4288 imMETHOD, /* waiting for method byte */
4289 imFLAG, /* waiting for flag byte */
4290 imDICT4, /* four dictionary check bytes to go */
4291 imDICT3, /* three dictionary check bytes to go */
4292 imDICT2, /* two dictionary check bytes to go */
4293 imDICT1, /* one dictionary check byte to go */
4294 imDICT0, /* waiting for inflateSetDictionary */
4295 imBLOCKS, /* decompressing blocks */
4296 imCHECK4, /* four check bytes to go */
4297 imCHECK3, /* three check bytes to go */
4298 imCHECK2, /* two check bytes to go */
4299 imCHECK1, /* one check byte to go */
4300 imDONE, /* finished check, done */
4302 } /* got an error--stay here */
4305 /* inflate private state */
4306 struct internal_state {
4309 inflate_mode mode; /* current inflate mode */
4311 /* mode dependent information */
4313 uInt method; /* if FLAGS, method byte */
4315 uLong was; /* computed check value */
4316 uLong need; /* stream check value */
4317 } check; /* if CHECK, check values to compare */
4318 uInt marker; /* if BAD, inflateSync's marker bytes count */
4319 } sub; /* submode */
4321 /* mode independent information */
4322 int nowrap; /* flag for no wrapper */
4323 uInt wbits; /* log2(window size) (8..15, defaults to 15) */
4324 inflate_blocks_statef
4325 *blocks; /* current inflate_blocks state */
4330 int inflateReset( z_streamp z ){
4331 if ( z == Z_NULL || z->state == Z_NULL ) {
4332 return Z_STREAM_ERROR;
4334 z->total_in = z->total_out = 0;
4336 z->state->mode = z->state->nowrap ? imBLOCKS : imMETHOD;
4337 inflate_blocks_reset( z->state->blocks, z, Z_NULL );
4338 Tracev( ( "inflate: reset\n" ) );
4343 int inflateEnd( z_streamp z ){
4344 if ( z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL ) {
4345 return Z_STREAM_ERROR;
4347 if ( z->state->blocks != Z_NULL ) {
4348 inflate_blocks_free( z->state->blocks, z );
4350 ZFREE( z, z->state );
4352 Tracev( ( "inflate: end\n" ) );
4358 int inflateInit2_( z_streamp z, int w, const char *version, int stream_size ){
4359 if ( version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
4360 stream_size != sizeof( z_stream ) ) {
4361 return Z_VERSION_ERROR;
4364 /* initialize state */
4365 if ( z == Z_NULL ) {
4366 return Z_STREAM_ERROR;
4369 if ( z->zalloc == Z_NULL ) {
4370 z->zalloc = ( void *( * )( void *, unsigned, unsigned ) )zcalloc;
4371 z->opaque = (voidp)0;
4373 if ( z->zfree == Z_NULL ) {
4374 z->zfree = ( void ( * )( void *, void * ) )zcfree;
4376 if ( ( z->state = (struct internal_state *)
4377 ZALLOC( z,1,sizeof( struct internal_state ) ) ) == Z_NULL ) {
4380 z->state->blocks = Z_NULL;
4382 /* handle undocumented nowrap option (no zlib header or check) */
4383 z->state->nowrap = 0;
4386 z->state->nowrap = 1;
4389 /* set window size */
4390 if ( w < 8 || w > 15 ) {
4392 return Z_STREAM_ERROR;
4394 z->state->wbits = (uInt)w;
4396 /* create inflate_blocks state */
4397 if ( ( z->state->blocks =
4398 inflate_blocks_new( z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w ) )
4403 Tracev( ( "inflate: allocated\n" ) );
4411 int inflateInit_( z_streamp z, const char *version, int stream_size ){
4412 return inflateInit2_( z, DEF_WBITS, version, stream_size );
4416 #define iNEEDBYTE {if ( z->avail_in == 0 ) {return r; } r = f; }
4417 #define iNEXTBYTE ( z->avail_in--,z->total_in++,*z->next_in++ )
4419 int inflate( z_streamp z, int f ){
4423 if ( z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL ) {
4424 return Z_STREAM_ERROR;
4426 f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
4428 while ( 1 ) switch ( z->state->mode )
4432 if ( ( ( z->state->sub.method = iNEXTBYTE ) & 0xf ) != Z_DEFLATED ) {
4433 z->state->mode = imBAD;
4434 z->msg = (char*)"unknown compression method";
4435 z->state->sub.marker = 5; /* can't try inflateSync */
4438 if ( ( z->state->sub.method >> 4 ) + 8 > z->state->wbits ) {
4439 z->state->mode = imBAD;
4440 z->msg = (char*)"invalid window size";
4441 z->state->sub.marker = 5; /* can't try inflateSync */
4444 z->state->mode = imFLAG;
4448 if ( ( ( z->state->sub.method << 8 ) + b ) % 31 ) {
4449 z->state->mode = imBAD;
4450 z->msg = (char*)"incorrect header check";
4451 z->state->sub.marker = 5; /* can't try inflateSync */
4454 Tracev( ( "inflate: zlib header ok\n" ) );
4455 if ( !( b & PRESET_DICT ) ) {
4456 z->state->mode = imBLOCKS;
4459 z->state->mode = imDICT4;
4462 z->state->sub.check.need = (uLong)iNEXTBYTE << 24;
4463 z->state->mode = imDICT3;
4466 z->state->sub.check.need += (uLong)iNEXTBYTE << 16;
4467 z->state->mode = imDICT2;
4470 z->state->sub.check.need += (uLong)iNEXTBYTE << 8;
4471 z->state->mode = imDICT1;
4474 z->state->sub.check.need += (uLong)iNEXTBYTE;
4475 z->adler = z->state->sub.check.need;
4476 z->state->mode = imDICT0;
4479 z->state->mode = imBAD;
4480 z->msg = (char*)"need dictionary";
4481 z->state->sub.marker = 0; /* can try inflateSync */
4482 return Z_STREAM_ERROR;
4484 r = inflate_blocks( z->state->blocks, z, r );
4485 if ( r == Z_DATA_ERROR ) {
4486 z->state->mode = imBAD;
4487 z->state->sub.marker = 0; /* can try inflateSync */
4493 if ( r != Z_STREAM_END ) {
4497 inflate_blocks_reset( z->state->blocks, z, &z->state->sub.check.was );
4498 if ( z->state->nowrap ) {
4499 z->state->mode = imDONE;
4502 z->state->mode = imCHECK4;
4505 z->state->sub.check.need = (uLong)iNEXTBYTE << 24;
4506 z->state->mode = imCHECK3;
4509 z->state->sub.check.need += (uLong)iNEXTBYTE << 16;
4510 z->state->mode = imCHECK2;
4513 z->state->sub.check.need += (uLong)iNEXTBYTE << 8;
4514 z->state->mode = imCHECK1;
4517 z->state->sub.check.need += (uLong)iNEXTBYTE;
4519 if ( z->state->sub.check.was != z->state->sub.check.need ) {
4520 z->state->mode = imBAD;
4521 z->msg = (char*)"incorrect data check";
4522 z->state->sub.marker = 5; /* can't try inflateSync */
4525 Tracev( ( "inflate: zlib check ok\n" ) );
4526 z->state->mode = imDONE;
4528 return Z_STREAM_END;
4530 return Z_DATA_ERROR;
4532 return Z_STREAM_ERROR;
4534 #ifdef NEED_DUMMY_RETURN
4535 return Z_STREAM_ERROR; /* Some dumb compilers complain without this */
4540 int inflateSetDictionary( z_streamp z, const Byte *dictionary, uInt dictLength ){
4541 uInt length = dictLength;
4543 if ( z == Z_NULL || z->state == Z_NULL || z->state->mode != imDICT0 ) {
4544 return Z_STREAM_ERROR;
4547 if ( adler32( 1L, dictionary, dictLength ) != z->adler ) {
4548 return Z_DATA_ERROR;
4552 if ( length >= ( (uInt)1 << z->state->wbits ) ) {
4553 length = ( 1 << z->state->wbits ) - 1;
4554 dictionary += dictLength - length;
4556 inflate_set_dictionary( z->state->blocks, dictionary, length );
4557 z->state->mode = imBLOCKS;
4562 int inflateSync( z_streamp z ){
4563 uInt n; /* number of bytes to look at */
4564 Byte *p; /* pointer to bytes */
4565 uInt m; /* number of marker bytes found in a row */
4566 uLong r, w; /* temporaries to save total_in and total_out */
4569 if ( z == Z_NULL || z->state == Z_NULL ) {
4570 return Z_STREAM_ERROR;
4572 if ( z->state->mode != imBAD ) {
4573 z->state->mode = imBAD;
4574 z->state->sub.marker = 0;
4576 if ( ( n = z->avail_in ) == 0 ) {
4580 m = z->state->sub.marker;
4583 while ( n && m < 4 )
4585 static const Byte mark[4] = {0, 0, 0xff, 0xff};
4586 if ( *p == mark[m] ) {
4599 z->total_in += p - z->next_in;
4602 z->state->sub.marker = m;
4604 /* return no joy or set up to restart on a new block */
4606 return Z_DATA_ERROR;
4608 r = z->total_in; w = z->total_out;
4610 z->total_in = r; z->total_out = w;
4611 z->state->mode = imBLOCKS;
4616 /* Returns true if inflate is currently at the end of a block generated
4617 * by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
4618 * implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
4619 * but removes the length bytes of the resulting empty stored block. When
4620 * decompressing, PPP checks that at the end of input packet, inflate is
4621 * waiting for these length bytes.
4623 int inflateSyncPoint( z_streamp z ){
4624 if ( z == Z_NULL || z->state == Z_NULL || z->state->blocks == Z_NULL ) {
4625 return Z_STREAM_ERROR;
4627 return inflate_blocks_sync_point( z->state->blocks );
4630 voidp zcalloc( voidp opaque, unsigned items, unsigned size ){
4632 items += size - size; /* make compiler happy */
4634 return (voidp)malloc( items * size );
4637 void zcfree( voidp opaque, voidp ptr ){
4640 return; /* make compiler happy */