8d89a9eccf9ff606a0ad4656ea087d9e790ebcde
[xonotic/netradiant.git] / plugins / vfspk3 / unzip.cpp
1 /*****************************************************************************
2 * name:         unzip.c
3 *
4 * desc:         IO on .zip files using portions of zlib
5 *
6 *
7 *****************************************************************************/
8
9 #include <stdlib.h>
10 #include <stdio.h>
11 #include <string.h>
12 #include "unzip-vfspk3.h"
13
14 typedef unsigned char byte;
15
16 /* unzip.h -- IO for uncompress .zip files using zlib
17    Version 0.15 beta, Mar 19th, 1998,
18
19    Copyright (C) 1998 Gilles Vollant
20
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
25
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
30
31    Condition of use and distribution are the same than zlib :
32
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.
36
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:
40
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.
48
49
50  */
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 */
55
56 /* zlib.h -- interface of the 'zlib' general purpose compression library
57    version 1.1.3, July 9th, 1998
58
59    Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
60
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.
64
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:
68
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.
76
77    Jean-loup Gailly        Mark Adler
78    jloup@gzip.org          madler@alumni.caltech.edu
79
80
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).
84  */
85
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
89  */
90
91
92 #ifndef _ZCONF_H
93 #define _ZCONF_H
94
95 /* Maximum value for memLevel in deflateInit2 */
96 #ifndef MAX_MEM_LEVEL
97 #  ifdef MAXSEG_64K
98 #    define MAX_MEM_LEVEL 8
99 #  else
100 #    define MAX_MEM_LEVEL 9
101 #  endif
102 #endif
103
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
107  * gzip.)
108  */
109 #ifndef MAX_WBITS
110 #  define MAX_WBITS   15 /* 32K LZ77 window */
111 #endif
112
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).
120
121    The memory requirements for inflate are (in bytes) 1 << windowBits
122    that is, 32K for windowBits=15 (default value) plus a few kilobytes
123    for small objects.
124  */
125
126 /* Type declarations */
127
128 #ifndef OF /* function prototypes */
129 #define OF( args )  args
130 #endif
131
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 */
135 typedef Byte    *voidp;
136
137 #ifndef SEEK_SET
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" */
141 #endif
142
143 #endif /* _ZCONF_H */
144
145 #define ZLIB_VERSION "1.1.3"
146
147 /*
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
152    stream interface.
153
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.
159
160      The library also supports reading and writing files in gzip (.gz) format
161    with an interface similar to that of stdio.
162
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.
166  */
167
168 /*
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.
174
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
178    opaque value.
179
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
182    thread safe.
183
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).
192
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
197    a single step).
198  */
199
200 /* constants */
201
202 #define Z_NO_FLUSH      0
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
206 #define Z_FINISH        4
207 /* Allowed flush values; see deflate() below for details */
208
209 #define Z_OK            0
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.
220  */
221
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 */
227
228 #define Z_FILTERED            1
229 #define Z_HUFFMAN_ONLY        2
230 #define Z_DEFAULT_STRATEGY    0
231 /* compression strategy; see deflateInit2() below for details */
232
233 #define Z_BINARY   0
234 #define Z_ASCII    1
235 #define Z_UNKNOWN  2
236 /* Possible values of the data_type field */
237
238 #define Z_DEFLATED   8
239 /* The deflate compression method (the only one supported in this version) */
240
241 #define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
242
243 #define zlib_version zlibVersion()
244 /* for compatibility with versions < 1.0.2 */
245
246 /* basic functions */
247
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.
253  */
254
255 /*
256    int deflateInit OF((z_streamp strm, int level));
257
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.
262
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).
268
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().
275  */
276
277
278 int deflate OF( ( z_streamp strm, int flush ) );
279 /*
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
283    forced to flush.
284
285     The detailed semantics are as follows. deflate performs one or both of the
286    following actions:
287
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().
292
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.
298
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.
307
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.
314
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
319    the compression.
320
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
324    avail_out).
325
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.
333
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.
338
339     deflate() sets strm->adler to the adler32 checksum of all input read
340    so (that is, total_in bytes).
341
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.
346
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).
353  */
354
355
356 int deflateEnd OF( (z_streamp strm) );
357 /*
358      All dynamically allocated data structures for this stream are freed.
359    This function discards any unprocessed input and does not flush any
360    pending output.
361
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
366    deallocated).
367  */
368
369
370 /*
371    int inflateInit OF((z_streamp strm));
372
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.
381
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.)
388  */
389
390
391 int inflate OF( ( z_streamp strm, int flush ) );
392 /*
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.
397
398    The detailed semantics are as follows. inflate performs one or both of the
399    following actions:
400
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().
405
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).
410
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.
419
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
424    as possible anyway.
425
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.
436
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.
445
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
456    compression block.
457  */
458
459
460 int inflateEnd OF( (z_streamp strm) );
461 /*
462      All dynamically allocated data structures for this stream are freed.
463    This function discards any unprocessed input and does not flush any
464    pending output.
465
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).
469  */
470
471 /* Advanced functions */
472
473 /*
474     The following functions are needed only in some special applications.
475  */
476
477 /*
478    int deflateInit2 OF((z_streamp strm,
479                                      int  level,
480                                      int  method,
481                                      int  windowBits,
482                                      int  memLevel,
483                                      int  strategy));
484
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
487    the caller.
488
489      The method parameter is the compression method. It must be Z_DEFLATED in
490    this version of the library.
491
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.
497
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.
503
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.
514
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().
519  */
520
521 int deflateSetDictionary OF( ( z_streamp strm,
522                                                            const Byte * dictionary,
523                                                            uInt dictLength ) );
524 /*
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).
530
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.
537
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.
543
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.)
549
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().
555  */
556
557 int deflateCopy OF( ( z_streamp dest,
558                                           z_streamp source ) );
559 /*
560      Sets the destination stream as a complete copy of the source stream.
561
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.
568
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
572    destination.
573  */
574
575 int deflateReset OF( (z_streamp strm) );
576 /*
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.
581
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).
584  */
585
586 int deflateParams OF( ( z_streamp strm,
587                                                 int level,
588                                                 int strategy ) );
589 /*
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().
597
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.
601
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.
605  */
606
607 /*
608    int inflateInit2 OF((z_streamp strm,
609                                      int  windowBits));
610
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.
614
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.
621
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.)
628  */
629
630 int inflateSetDictionary OF( ( z_streamp strm,
631                                                            const Byte * dictionary,
632                                                            uInt dictLength ) );
633 /*
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).
640
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
646    inflate().
647  */
648
649 int inflateSync OF( (z_streamp strm) );
650 /*
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.
654
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.
662  */
663
664 int inflateReset OF( (z_streamp strm) );
665 /*
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.
669
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).
672  */
673
674
675 /* utility functions */
676
677 /*
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.
683  */
684
685 int compress OF( ( Byte * dest,   uLong * destLen,
686                                    const Byte * source, uLong sourceLen ) );
687 /*
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
692    compressed buffer.
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
697    buffer.
698  */
699
700 int compress2 OF( ( Byte * dest,   uLong * destLen,
701                                         const Byte * source, uLong sourceLen,
702                                         int level ) );
703 /*
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.
709
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.
713  */
714
715 int uncompress OF( ( Byte * dest,   uLong * destLen,
716                                          const Byte * source, uLong sourceLen ) );
717 /*
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.
727
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.
731  */
732
733
734 typedef voidp gzFile;
735
736 gzFile gzopen OF( ( const char *path, const char *mode ) );
737 /*
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.)
743
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.
746
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).  */
751
752 gzFile gzdopen OF( ( int fd, const char *mode ) );
753 /*
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.
763  */
764
765 int gzsetparams OF( ( gzFile file, int level, int strategy ) );
766 /*
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
770    opened for writing.
771  */
772
773 int gzread OF( ( gzFile file, voidp buf, unsigned len ) );
774 /*
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). */
780
781 int gzwrite OF( ( gzFile file,
782                                   const voidp buf, unsigned len ) );
783 /*
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).
787  */
788
789 int gzprintf OF( ( gzFile file, const char *format, ... ) );
790 /*
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).
794  */
795
796 int gzputs OF( ( gzFile file, const char *s ) );
797 /*
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.
801  */
802
803 char * gzgets OF( ( gzFile file, char *buf, int len ) );
804 /*
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
808    character.
809       gzgets returns buf, or Z_NULL in case of error.
810  */
811
812 int gzputc OF( ( gzFile file, int c ) );
813 /*
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.
816  */
817
818 int gzgetc OF( (gzFile file) );
819 /*
820       Reads one byte from the compressed file. gzgetc returns this byte
821    or -1 in case of end of file or error.
822  */
823
824 int gzflush OF( ( gzFile file, int flush ) );
825 /*
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
831    degrade compression.
832  */
833
834 long gzseek OF( ( gzFile file,
835                                   long offset, int whence ) );
836 /*
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
844    starting position.
845
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.
850  */
851
852 int gzrewind OF( (gzFile file) );
853 /*
854      Rewinds the given file. This function is supported only for reading.
855
856    gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
857  */
858
859 long gztell OF( (gzFile file) );
860 /*
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.
864
865    gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
866  */
867
868 int gzeof OF( (gzFile file) );
869 /*
870      Returns 1 when EOF has previously been detected reading the given
871    input stream, otherwise zero.
872  */
873
874 int gzclose OF( (gzFile file) );
875 /*
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).
879  */
880
881 const char * gzerror OF( ( gzFile file, int *errnum ) );
882 /*
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.
888  */
889
890 /* checksum functions */
891
892 /*
893      These functions are not related to compression but are exported
894    anyway because they might be useful in applications using the
895    compression library.
896  */
897
898 uLong adler32 OF( ( uLong adler, const Byte * buf, uInt len ) );
899
900 /*
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:
906
907      uLong adler = adler32(0L, Z_NULL, 0);
908
909      while (read_buffer(buffer, length) != EOF) {
910        adler = adler32(adler, buffer, length);
911      }
912      if (adler != original_adler) error();
913  */
914
915 uLong crc32 OF( ( uLong crc, const Byte * buf, uInt len ) );
916 /*
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.
921    Usage example:
922
923      uLong crc = crc32(0L, Z_NULL, 0);
924
925      while (read_buffer(buffer, length) != EOF) {
926        crc = crc32(crc, buffer, length);
927      }
928      if (crc != original_crc) error();
929  */
930
931 // private stuff to not include cmdlib.h
932 /*
933    ============================================================================
934
935                     BYTE ORDER FUNCTIONS
936
937    ============================================================================
938  */
939
940 #ifdef _SGI_SOURCE
941 #define __BIG_ENDIAN__
942 #endif
943
944 #ifdef __BIG_ENDIAN__
945
946 short   __LittleShort( short l ){
947         byte b1,b2;
948
949         b1 = l & 255;
950         b2 = ( l >> 8 ) & 255;
951
952         return ( b1 << 8 ) + b2;
953 }
954
955 short   __BigShort( short l ){
956         return l;
957 }
958
959
960 int    __LittleLong( int l ){
961         byte b1,b2,b3,b4;
962
963         b1 = l & 255;
964         b2 = ( l >> 8 ) & 255;
965         b3 = ( l >> 16 ) & 255;
966         b4 = ( l >> 24 ) & 255;
967
968         return ( (int)b1 << 24 ) + ( (int)b2 << 16 ) + ( (int)b3 << 8 ) + b4;
969 }
970
971 int    __BigLong( int l ){
972         return l;
973 }
974
975
976 float   __LittleFloat( float l ){
977         union {byte b[4]; float f; } in, out;
978
979         in.f = l;
980         out.b[0] = in.b[3];
981         out.b[1] = in.b[2];
982         out.b[2] = in.b[1];
983         out.b[3] = in.b[0];
984
985         return out.f;
986 }
987
988 float   __BigFloat( float l ){
989         return l;
990 }
991
992
993 #else
994
995
996 short   __BigShort( short l ){
997         byte b1,b2;
998
999         b1 = l & 255;
1000         b2 = ( l >> 8 ) & 255;
1001
1002         return ( b1 << 8 ) + b2;
1003 }
1004
1005 short   __LittleShort( short l ){
1006         return l;
1007 }
1008
1009
1010 int    __BigLong( int l ){
1011         byte b1,b2,b3,b4;
1012
1013         b1 = l & 255;
1014         b2 = ( l >> 8 ) & 255;
1015         b3 = ( l >> 16 ) & 255;
1016         b4 = ( l >> 24 ) & 255;
1017
1018         return ( (int)b1 << 24 ) + ( (int)b2 << 16 ) + ( (int)b3 << 8 ) + b4;
1019 }
1020
1021 int    __LittleLong( int l ){
1022         return l;
1023 }
1024
1025 float   __BigFloat( float l ){
1026         union {byte b[4]; float f; } in, out;
1027
1028         in.f = l;
1029         out.b[0] = in.b[3];
1030         out.b[1] = in.b[2];
1031         out.b[2] = in.b[1];
1032         out.b[3] = in.b[0];
1033
1034         return out.f;
1035 }
1036
1037 float   __LittleFloat( float l ){
1038         return l;
1039 }
1040
1041
1042
1043 #endif
1044
1045
1046
1047
1048 /* various hacks, don't look :) */
1049
1050 /* deflateInit and inflateInit are macros to allow checking the zlib version
1051  * and the compiler's view of z_stream:
1052  */
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 ) )
1072
1073
1074 const char   * zError OF( (int err) );
1075 int inflateSyncPoint OF( (z_streamp z) );
1076 const uLong * get_crc_table OF( (void) );
1077
1078 typedef unsigned char uch;
1079 typedef unsigned short ush;
1080 typedef unsigned long ulg;
1081
1082 extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
1083 /* (size given to avoid silly warnings with Visual C++) */
1084
1085 #define ERR_MSG( err ) z_errmsg[Z_NEED_DICT - ( err )]
1086
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 */
1090
1091 /* common constants */
1092
1093 #ifndef DEF_WBITS
1094 #  define DEF_WBITS MAX_WBITS
1095 #endif
1096 /* default windowBits for decompression. MAX_WBITS is for compression only */
1097
1098 #if MAX_MEM_LEVEL >= 8
1099 #  define DEF_MEM_LEVEL 8
1100 #else
1101 #  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
1102 #endif
1103 /* default memLevel */
1104
1105 #define STORED_BLOCK 0
1106 #define STATIC_TREES 1
1107 #define DYN_TREES    2
1108 /* The three kinds of block type */
1109
1110 #define MIN_MATCH  3
1111 #define MAX_MATCH  258
1112 /* The minimum and maximum match lengths */
1113
1114 #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
1115
1116 /* target dependencies */
1117
1118 /* Common defaults */
1119
1120 #ifndef OS_CODE
1121 #  define OS_CODE  0x03  /* assume Unix */
1122 #endif
1123
1124 #ifndef F_OPEN
1125 #  define F_OPEN( name, mode ) fopen( ( name ), ( mode ) )
1126 #endif
1127
1128 /* functions */
1129
1130 #ifdef HAVE_STRERROR
1131 extern char *strerror OF( (int) );
1132 #  define zstrerror( errnum ) strerror( errnum )
1133 #else
1134 #  define zstrerror( errnum ) ""
1135 #endif
1136
1137 #define zmemcpy memcpy
1138 #define zmemcmp memcmp
1139 #define zmemzero( dest, len ) memset( dest, 0, len )
1140
1141 /* Diagnostic functions */
1142 #ifdef _ZIP_DEBUG_
1143 int z_verbose = 0;
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 ; }}
1151 #else
1152 #  define Assert( cond,msg )
1153 #  define Trace( x )
1154 #  define Tracev( x )
1155 #  define Tracevv( x )
1156 #  define Tracec( c,x )
1157 #  define Tracecv( c,x )
1158 #endif
1159
1160
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 ) );
1164
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 ); }}
1169
1170
1171 #if !defined( unix ) && !defined( CASESENSITIVITYDEFAULT_YES ) && \
1172         !defined( CASESENSITIVITYDEFAULT_NO )
1173 #define CASESENSITIVITYDEFAULT_NO
1174 #endif
1175
1176
1177 #ifndef UNZ_BUFSIZE
1178 #define UNZ_BUFSIZE ( 65536 )
1179 #endif
1180
1181 #ifndef UNZ_MAXFILENAMEINZIP
1182 #define UNZ_MAXFILENAMEINZIP ( 256 )
1183 #endif
1184
1185 #ifndef ALLOC
1186 # define ALLOC( size ) ( malloc( size ) )
1187 #endif
1188 #ifndef TRYFREE
1189 # define TRYFREE( p ) {if ( p ) {free( p ); }}
1190 #endif
1191
1192 #define SIZECENTRALDIRITEM ( 0x2e )
1193 #define SIZEZIPLOCALHEADER ( 0x1e )
1194
1195
1196
1197 /* ===========================================================================
1198      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
1199    for end of file.
1200    IN assertion: the stream s has been sucessfully opened for reading.
1201  */
1202
1203 /*
1204    static int unzlocal_getByte(FILE *fin,int *pi)
1205    {
1206     unsigned char c;
1207     int err = fread(&c, 1, 1, fin);
1208     if (err==1)
1209     {
1210    *pi = (int)c;
1211         return UNZ_OK;
1212     }
1213     else
1214     {
1215         if (ferror(fin))
1216             return UNZ_ERRNO;
1217         else
1218             return UNZ_EOF;
1219     }
1220    }
1221  */
1222
1223 /* ===========================================================================
1224    Reads a long in LSB order from the given gz_stream. Sets
1225  */
1226 static int unzlocal_getShort( FILE* fin, uLong *pX ){
1227         short v;
1228
1229         fread( &v, sizeof( v ), 1, fin );
1230
1231         *pX = __LittleShort( v );
1232         return UNZ_OK;
1233
1234 /*
1235     uLong x ;
1236     int i;
1237     int err;
1238
1239     err = unzlocal_getByte(fin,&i);
1240     x = (uLong)i;
1241
1242     if (err==UNZ_OK)
1243         err = unzlocal_getByte(fin,&i);
1244     x += ((uLong)i)<<8;
1245
1246     if (err==UNZ_OK)
1247    *pX = x;
1248     else
1249    *pX = 0;
1250     return err;
1251  */
1252 }
1253
1254 static int unzlocal_getLong( FILE *fin, uLong *pX ){
1255         int v;
1256
1257         fread( &v, sizeof( v ), 1, fin );
1258
1259         *pX = __LittleLong( v );
1260         return UNZ_OK;
1261
1262 /*
1263     uLong x ;
1264     int i;
1265     int err;
1266
1267     err = unzlocal_getByte(fin,&i);
1268     x = (uLong)i;
1269
1270     if (err==UNZ_OK)
1271         err = unzlocal_getByte(fin,&i);
1272     x += ((uLong)i)<<8;
1273
1274     if (err==UNZ_OK)
1275         err = unzlocal_getByte(fin,&i);
1276     x += ((uLong)i)<<16;
1277
1278     if (err==UNZ_OK)
1279         err = unzlocal_getByte(fin,&i);
1280     x += ((uLong)i)<<24;
1281
1282     if (err==UNZ_OK)
1283    *pX = x;
1284     else
1285    *pX = 0;
1286     return err;
1287  */
1288 }
1289
1290
1291 /* My own strcmpi / strcasecmp */
1292 static int strcmpcasenosensitive_internal( const char* fileName1,const char* fileName2 ){
1293         for (;; )
1294         {
1295                 char c1 = *( fileName1++ );
1296                 char c2 = *( fileName2++ );
1297                 if ( ( c1 >= 'a' ) && ( c1 <= 'z' ) ) {
1298                         c1 -= 0x20;
1299                 }
1300                 if ( ( c2 >= 'a' ) && ( c2 <= 'z' ) ) {
1301                         c2 -= 0x20;
1302                 }
1303                 if ( c1 == '\0' ) {
1304                         return ( ( c2 == '\0' ) ? 0 : -1 );
1305                 }
1306                 if ( c2 == '\0' ) {
1307                         return 1;
1308                 }
1309                 if ( c1 < c2 ) {
1310                         return -1;
1311                 }
1312                 if ( c1 > c2 ) {
1313                         return 1;
1314                 }
1315         }
1316 }
1317
1318
1319 #ifdef  CASESENSITIVITYDEFAULT_NO
1320 #define CASESENSITIVITYDEFAULTVALUE 2
1321 #else
1322 #define CASESENSITIVITYDEFAULTVALUE 1
1323 #endif
1324
1325 #ifndef STRCMPCASENOSENTIVEFUNCTION
1326 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
1327 #endif
1328
1329 /*
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
1333                                                                 or strcasecmp)
1334    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
1335         (like 1 on Unix, 2 on Windows)
1336
1337  */
1338 extern int unzStringFileNameCompare( const char* fileName1,const char* fileName2,int iCaseSensitivity ){
1339         if ( iCaseSensitivity == 0 ) {
1340                 iCaseSensitivity = CASESENSITIVITYDEFAULTVALUE;
1341         }
1342
1343         if ( iCaseSensitivity == 1 ) {
1344                 return strcmp( fileName1,fileName2 );
1345         }
1346
1347         return STRCMPCASENOSENTIVEFUNCTION( fileName1,fileName2 );
1348 }
1349
1350 #define BUFREADCOMMENT ( 0x400 )
1351
1352 /*
1353    Locate the Central directory of a zipfile (at the end, just before
1354     the global comment)
1355  */
1356 static uLong unzlocal_SearchCentralDir( FILE *fin ){
1357         unsigned char* buf;
1358         uLong uSizeFile;
1359         uLong uBackRead;
1360         uLong uMaxBack = 0xffff; /* maximum size of global comment */
1361         uLong uPosFound = 0;
1362
1363         if ( fseek( fin,0,SEEK_END ) != 0 ) {
1364                 return 0;
1365         }
1366
1367
1368         uSizeFile = ftell( fin );
1369
1370         if ( uMaxBack > uSizeFile ) {
1371                 uMaxBack = uSizeFile;
1372         }
1373
1374         buf = (unsigned char*)malloc( BUFREADCOMMENT + 4 );
1375         if ( buf == NULL ) {
1376                 return 0;
1377         }
1378
1379         uBackRead = 4;
1380         while ( uBackRead < uMaxBack )
1381         {
1382                 uLong uReadSize,uReadPos ;
1383                 int i;
1384                 if ( uBackRead + BUFREADCOMMENT > uMaxBack ) {
1385                         uBackRead = uMaxBack;
1386                 }
1387                 else{
1388                         uBackRead += BUFREADCOMMENT;
1389                 }
1390                 uReadPos = uSizeFile - uBackRead ;
1391
1392                 uReadSize = ( ( BUFREADCOMMENT + 4 ) < ( uSizeFile - uReadPos ) ) ?
1393                                         ( BUFREADCOMMENT + 4 ) : ( uSizeFile - uReadPos );
1394                 if ( fseek( fin,uReadPos,SEEK_SET ) != 0 ) {
1395                         break;
1396                 }
1397
1398                 if ( fread( buf,(uInt)uReadSize,1,fin ) != 1 ) {
1399                         break;
1400                 }
1401
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;
1406                                 break;
1407                         }
1408
1409                 if ( uPosFound != 0 ) {
1410                         break;
1411                 }
1412         }
1413         free( buf );
1414         return uPosFound;
1415 }
1416
1417 extern unzFile unzReOpen( const char* path, unzFile file ){
1418         unz_s *s;
1419         FILE * fin;
1420
1421         fin = fopen( path,"rb" );
1422         if ( fin == NULL ) {
1423                 return NULL;
1424         }
1425
1426         s = (unz_s*)malloc( sizeof( unz_s ) );
1427         memcpy( s, (unz_s*)file, sizeof( unz_s ) );
1428
1429         s->file = fin;
1430         return (unzFile)s;
1431 }
1432
1433 /*
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
1436      "zlib/zlib109.zip".
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.
1441  */
1442 extern unzFile unzOpen( const char* path ){
1443         unz_s us;
1444         unz_s *s;
1445         uLong central_pos,uL;
1446         FILE * fin ;
1447
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
1453                                        the central dir
1454                                        (same than number_entry on nospan) */
1455
1456         int err = UNZ_OK;
1457
1458         fin = fopen( path,"rb" );
1459         if ( fin == NULL ) {
1460                 return NULL;
1461         }
1462
1463         central_pos = unzlocal_SearchCentralDir( fin );
1464         if ( central_pos == 0 ) {
1465                 err = UNZ_ERRNO;
1466         }
1467
1468         if ( fseek( fin,central_pos,SEEK_SET ) != 0 ) {
1469                 err = UNZ_ERRNO;
1470         }
1471
1472         /* the signature, already checked */
1473         if ( unzlocal_getLong( fin,&uL ) != UNZ_OK ) {
1474                 err = UNZ_ERRNO;
1475         }
1476
1477         /* number of this disk */
1478         if ( unzlocal_getShort( fin,&number_disk ) != UNZ_OK ) {
1479                 err = UNZ_ERRNO;
1480         }
1481
1482         /* number of the disk with the start of the central directory */
1483         if ( unzlocal_getShort( fin,&number_disk_with_CD ) != UNZ_OK ) {
1484                 err = UNZ_ERRNO;
1485         }
1486
1487         /* total number of entries in the central dir on this disk */
1488         if ( unzlocal_getShort( fin,&us.gi.number_entry ) != UNZ_OK ) {
1489                 err = UNZ_ERRNO;
1490         }
1491
1492         /* total number of entries in the central dir */
1493         if ( unzlocal_getShort( fin,&number_entry_CD ) != UNZ_OK ) {
1494                 err = UNZ_ERRNO;
1495         }
1496
1497         if ( ( number_entry_CD != us.gi.number_entry ) ||
1498                  ( number_disk_with_CD != 0 ) ||
1499                  ( number_disk != 0 ) ) {
1500                 err = UNZ_BADZIPFILE;
1501         }
1502
1503         /* size of the central directory */
1504         if ( unzlocal_getLong( fin,&us.size_central_dir ) != UNZ_OK ) {
1505                 err = UNZ_ERRNO;
1506         }
1507
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 ) {
1511                 err = UNZ_ERRNO;
1512         }
1513
1514         /* zipfile comment length */
1515         if ( unzlocal_getShort( fin,&us.gi.size_comment ) != UNZ_OK ) {
1516                 err = UNZ_ERRNO;
1517         }
1518
1519         if ( ( central_pos < us.offset_central_dir + us.size_central_dir ) &&
1520                  ( err == UNZ_OK ) ) {
1521                 err = UNZ_BADZIPFILE;
1522         }
1523
1524         if ( err != UNZ_OK ) {
1525                 fclose( fin );
1526                 return NULL;
1527         }
1528
1529         us.file = fin;
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;
1534
1535
1536         s = (unz_s*)malloc( sizeof( unz_s ) );
1537         *s = us;
1538 //      unzGoToFirstFile((unzFile)s);
1539         return (unzFile)s;
1540 }
1541
1542
1543 /*
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 ){
1549         unz_s* s;
1550         if ( file == NULL ) {
1551                 return UNZ_PARAMERROR;
1552         }
1553         s = (unz_s*)file;
1554
1555         if ( s->pfile_in_zip_read != NULL ) {
1556                 unzCloseCurrentFile( file );
1557         }
1558
1559         fclose( s->file );
1560         free( s );
1561         return UNZ_OK;
1562 }
1563
1564
1565 /*
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 ){
1570         unz_s* s;
1571         if ( file == NULL ) {
1572                 return UNZ_PARAMERROR;
1573         }
1574         s = (unz_s*)file;
1575         *pglobal_info = s->gi;
1576         return UNZ_OK;
1577 }
1578
1579
1580 /*
1581    Translate date/time from Dos format to tm_unz (readable more easilty)
1582  */
1583 static void unzlocal_DosDateToTmuDate( uLong ulDosDate, tm_unz* ptm ){
1584         uLong uDate;
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 ) ;
1589
1590         ptm->tm_hour = (uInt) ( ( ulDosDate & 0xF800 ) / 0x800 );
1591         ptm->tm_min =  (uInt) ( ( ulDosDate & 0x7E0 ) / 0x20 ) ;
1592         ptm->tm_sec =  (uInt) ( 2 * ( ulDosDate & 0x1f ) ) ;
1593 }
1594
1595 /*
1596    Get Info about the current file in the zipfile, with internal only info
1597  */
1598 static int unzlocal_GetCurrentFileInfoInternal( unzFile file,
1599                                                                                                 unz_file_info *pfile_info,
1600                                                                                                 unz_file_info_internal
1601                                                                                                 *pfile_info_internal,
1602                                                                                                 char *szFileName,
1603                                                                                                 uLong fileNameBufferSize,
1604                                                                                                 void *extraField,
1605                                                                                                 uLong extraFieldBufferSize,
1606                                                                                                 char *szComment,
1607                                                                                                 uLong commentBufferSize ){
1608         unz_s* s;
1609         unz_file_info file_info;
1610         unz_file_info_internal file_info_internal;
1611         int err = UNZ_OK;
1612         uLong uMagic;
1613         long lSeek = 0;
1614
1615         if ( file == NULL ) {
1616                 return UNZ_PARAMERROR;
1617         }
1618         s = (unz_s*)file;
1619         if ( fseek( s->file,s->pos_in_central_dir + s->byte_before_the_zipfile,SEEK_SET ) != 0 ) {
1620                 err = UNZ_ERRNO;
1621         }
1622
1623
1624         /* we check the magic */
1625         if ( err == UNZ_OK ) {
1626                 if ( unzlocal_getLong( s->file,&uMagic ) != UNZ_OK ) {
1627                         err = UNZ_ERRNO;
1628                 }
1629                 else if ( uMagic != 0x02014b50 ) {
1630                         err = UNZ_BADZIPFILE;
1631                 }
1632         }
1633
1634         if ( unzlocal_getShort( s->file,&file_info.version ) != UNZ_OK ) {
1635                 err = UNZ_ERRNO;
1636         }
1637
1638         if ( unzlocal_getShort( s->file,&file_info.version_needed ) != UNZ_OK ) {
1639                 err = UNZ_ERRNO;
1640         }
1641
1642         if ( unzlocal_getShort( s->file,&file_info.flag ) != UNZ_OK ) {
1643                 err = UNZ_ERRNO;
1644         }
1645
1646         if ( unzlocal_getShort( s->file,&file_info.compression_method ) != UNZ_OK ) {
1647                 err = UNZ_ERRNO;
1648         }
1649
1650         if ( unzlocal_getLong( s->file,&file_info.dosDate ) != UNZ_OK ) {
1651                 err = UNZ_ERRNO;
1652         }
1653
1654         unzlocal_DosDateToTmuDate( file_info.dosDate,&file_info.tmu_date );
1655
1656         if ( unzlocal_getLong( s->file,&file_info.crc ) != UNZ_OK ) {
1657                 err = UNZ_ERRNO;
1658         }
1659
1660         if ( unzlocal_getLong( s->file,&file_info.compressed_size ) != UNZ_OK ) {
1661                 err = UNZ_ERRNO;
1662         }
1663
1664         if ( unzlocal_getLong( s->file,&file_info.uncompressed_size ) != UNZ_OK ) {
1665                 err = UNZ_ERRNO;
1666         }
1667
1668         if ( unzlocal_getShort( s->file,&file_info.size_filename ) != UNZ_OK ) {
1669                 err = UNZ_ERRNO;
1670         }
1671
1672         if ( unzlocal_getShort( s->file,&file_info.size_file_extra ) != UNZ_OK ) {
1673                 err = UNZ_ERRNO;
1674         }
1675
1676         if ( unzlocal_getShort( s->file,&file_info.size_file_comment ) != UNZ_OK ) {
1677                 err = UNZ_ERRNO;
1678         }
1679
1680         if ( unzlocal_getShort( s->file,&file_info.disk_num_start ) != UNZ_OK ) {
1681                 err = UNZ_ERRNO;
1682         }
1683
1684         if ( unzlocal_getShort( s->file,&file_info.internal_fa ) != UNZ_OK ) {
1685                 err = UNZ_ERRNO;
1686         }
1687
1688         if ( unzlocal_getLong( s->file,&file_info.external_fa ) != UNZ_OK ) {
1689                 err = UNZ_ERRNO;
1690         }
1691
1692         if ( unzlocal_getLong( s->file,&file_info_internal.offset_curfile ) != UNZ_OK ) {
1693                 err = UNZ_ERRNO;
1694         }
1695
1696         lSeek += file_info.size_filename;
1697         if ( ( err == UNZ_OK ) && ( szFileName != NULL ) ) {
1698                 uLong uSizeRead ;
1699                 if ( file_info.size_filename < fileNameBufferSize ) {
1700                         *( szFileName + file_info.size_filename ) = '\0';
1701                         uSizeRead = file_info.size_filename;
1702                 }
1703                 else{
1704                         uSizeRead = fileNameBufferSize;
1705                 }
1706
1707                 if ( ( file_info.size_filename > 0 ) && ( fileNameBufferSize > 0 ) ) {
1708                         if ( fread( szFileName,(uInt)uSizeRead,1,s->file ) != 1 ) {
1709                                 err = UNZ_ERRNO;
1710                         }
1711                 }
1712                 lSeek -= uSizeRead;
1713         }
1714
1715
1716         if ( ( err == UNZ_OK ) && ( extraField != NULL ) ) {
1717                 uLong uSizeRead ;
1718                 if ( file_info.size_file_extra < extraFieldBufferSize ) {
1719                         uSizeRead = file_info.size_file_extra;
1720                 }
1721                 else{
1722                         uSizeRead = extraFieldBufferSize;
1723                 }
1724
1725                 if ( lSeek != 0 ) {
1726                         if ( fseek( s->file,lSeek,SEEK_CUR ) == 0 ) {
1727                                 lSeek = 0;
1728                         }
1729                         else{
1730                                 err = UNZ_ERRNO;
1731                         }
1732                 }
1733                 if ( ( file_info.size_file_extra > 0 ) && ( extraFieldBufferSize > 0 ) ) {
1734                         if ( fread( extraField,(uInt)uSizeRead,1,s->file ) != 1 ) {
1735                                 err = UNZ_ERRNO;
1736                         }
1737                 }
1738                 lSeek += file_info.size_file_extra - uSizeRead;
1739         }
1740         else{
1741                 lSeek += file_info.size_file_extra;
1742         }
1743
1744
1745         if ( ( err == UNZ_OK ) && ( szComment != NULL ) ) {
1746                 uLong uSizeRead ;
1747                 if ( file_info.size_file_comment < commentBufferSize ) {
1748                         *( szComment + file_info.size_file_comment ) = '\0';
1749                         uSizeRead = file_info.size_file_comment;
1750                 }
1751                 else{
1752                         uSizeRead = commentBufferSize;
1753                 }
1754
1755                 if ( lSeek != 0 ) {
1756                         if ( fseek( s->file,lSeek,SEEK_CUR ) == 0 ) {
1757                                 lSeek = 0;
1758                         }
1759                         else{
1760                                 err = UNZ_ERRNO;
1761                         }
1762                 }
1763                 if ( ( file_info.size_file_comment > 0 ) && ( commentBufferSize > 0 ) ) {
1764                         if ( fread( szComment,(uInt)uSizeRead,1,s->file ) != 1 ) {
1765                                 err = UNZ_ERRNO;
1766                         }
1767                 }
1768                 lSeek += file_info.size_file_comment - uSizeRead;
1769         }
1770         else{
1771                 lSeek += file_info.size_file_comment;
1772         }
1773
1774         if ( ( err == UNZ_OK ) && ( pfile_info != NULL ) ) {
1775                 *pfile_info = file_info;
1776         }
1777
1778         if ( ( err == UNZ_OK ) && ( pfile_info_internal != NULL ) ) {
1779                 *pfile_info_internal = file_info_internal;
1780         }
1781
1782         return err;
1783 }
1784
1785
1786
1787 /*
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.
1791  */
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 );
1800 }
1801
1802 /*
1803    Set the current file of the zipfile to the first file.
1804    return UNZ_OK if there is no problem
1805  */
1806 extern int unzGoToFirstFile( unzFile file ){
1807         int err = UNZ_OK;
1808         unz_s* s;
1809         if ( file == NULL ) {
1810                 return UNZ_PARAMERROR;
1811         }
1812         s = (unz_s*)file;
1813         s->pos_in_central_dir = s->offset_central_dir;
1814         s->num_file = 0;
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 );
1819         return err;
1820 }
1821
1822
1823 /*
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.
1827  */
1828 extern int unzGoToNextFile( unzFile file ){
1829         unz_s* s;
1830         int err;
1831
1832         if ( file == NULL ) {
1833                 return UNZ_PARAMERROR;
1834         }
1835         s = (unz_s*)file;
1836         if ( !s->current_file_ok ) {
1837                 return UNZ_END_OF_LIST_OF_FILE;
1838         }
1839         if ( s->num_file + 1 == s->gi.number_entry ) {
1840                 return UNZ_END_OF_LIST_OF_FILE;
1841         }
1842
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 ;
1845         s->num_file++;
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 );
1850         return err;
1851 }
1852
1853
1854 /*
1855    Try locate the file szFileName in the zipfile.
1856    For the iCaseSensitivity signification, see unzipStringFileNameCompare
1857
1858    return value :
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
1861  */
1862 extern int unzLocateFile( unzFile file, const char *szFileName, int iCaseSensitivity ){
1863         unz_s* s;
1864         int err;
1865
1866
1867         uLong num_fileSaved;
1868         uLong pos_in_central_dirSaved;
1869
1870
1871         if ( file == NULL ) {
1872                 return UNZ_PARAMERROR;
1873         }
1874
1875         if ( strlen( szFileName ) >= UNZ_MAXFILENAMEINZIP ) {
1876                 return UNZ_PARAMERROR;
1877         }
1878
1879         s = (unz_s*)file;
1880         if ( !s->current_file_ok ) {
1881                 return UNZ_END_OF_LIST_OF_FILE;
1882         }
1883
1884         num_fileSaved = s->num_file;
1885         pos_in_central_dirSaved = s->pos_in_central_dir;
1886
1887         err = unzGoToFirstFile( file );
1888
1889         while ( err == UNZ_OK )
1890         {
1891                 char szCurrentFileName[UNZ_MAXFILENAMEINZIP + 1];
1892                 unzGetCurrentFileInfo( file,NULL,
1893                                                            szCurrentFileName,sizeof( szCurrentFileName ) - 1,
1894                                                            NULL,0,NULL,0 );
1895                 if ( unzStringFileNameCompare( szCurrentFileName,
1896                                                                            szFileName,iCaseSensitivity ) == 0 ) {
1897                         return UNZ_OK;
1898                 }
1899                 err = unzGoToNextFile( file );
1900         }
1901
1902         s->num_file = num_fileSaved ;
1903         s->pos_in_central_dir = pos_in_central_dirSaved ;
1904         return err;
1905 }
1906
1907
1908 /*
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)
1914  */
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;
1921         int err = UNZ_OK;
1922
1923         *piSizeVar = 0;
1924         *poffset_local_extrafield = 0;
1925         *psize_local_extrafield = 0;
1926
1927         if ( fseek( s->file,s->cur_file_info_internal.offset_curfile +
1928                                 s->byte_before_the_zipfile,SEEK_SET ) != 0 ) {
1929                 return UNZ_ERRNO;
1930         }
1931
1932
1933         if ( err == UNZ_OK ) {
1934                 if ( unzlocal_getLong( s->file,&uMagic ) != UNZ_OK ) {
1935                         err = UNZ_ERRNO;
1936                 }
1937                 else if ( uMagic != 0x04034b50 ) {
1938                         err = UNZ_BADZIPFILE;
1939                 }
1940         }
1941
1942         if ( unzlocal_getShort( s->file,&uData ) != UNZ_OK ) {
1943                 err = UNZ_ERRNO;
1944         }
1945 /*
1946     else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
1947         err=UNZ_BADZIPFILE;
1948  */
1949         if ( unzlocal_getShort( s->file,&uFlags ) != UNZ_OK ) {
1950                 err = UNZ_ERRNO;
1951         }
1952
1953         if ( unzlocal_getShort( s->file,&uData ) != UNZ_OK ) {
1954                 err = UNZ_ERRNO;
1955         }
1956         else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.compression_method ) ) {
1957                 err = UNZ_BADZIPFILE;
1958         }
1959
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;
1963         }
1964
1965         if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* date/time */
1966                 err = UNZ_ERRNO;
1967         }
1968
1969         if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* crc */
1970                 err = UNZ_ERRNO;
1971         }
1972         else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.crc ) &&
1973                           ( ( uFlags & 8 ) == 0 ) ) {
1974                 err = UNZ_BADZIPFILE;
1975         }
1976
1977         if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* size compr */
1978                 err = UNZ_ERRNO;
1979         }
1980         else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.compressed_size ) &&
1981                           ( ( uFlags & 8 ) == 0 ) ) {
1982                 err = UNZ_BADZIPFILE;
1983         }
1984
1985         if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* size uncompr */
1986                 err = UNZ_ERRNO;
1987         }
1988         else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.uncompressed_size ) &&
1989                           ( ( uFlags & 8 ) == 0 ) ) {
1990                 err = UNZ_BADZIPFILE;
1991         }
1992
1993
1994         if ( unzlocal_getShort( s->file,&size_filename ) != UNZ_OK ) {
1995                 err = UNZ_ERRNO;
1996         }
1997         else if ( ( err == UNZ_OK ) && ( size_filename != s->cur_file_info.size_filename ) ) {
1998                 err = UNZ_BADZIPFILE;
1999         }
2000
2001         *piSizeVar += (uInt)size_filename;
2002
2003         if ( unzlocal_getShort( s->file,&size_extra_field ) != UNZ_OK ) {
2004                 err = UNZ_ERRNO;
2005         }
2006         *poffset_local_extrafield = s->cur_file_info_internal.offset_curfile +
2007                                                                 SIZEZIPLOCALHEADER + size_filename;
2008         *psize_local_extrafield = (uInt)size_extra_field;
2009
2010         *piSizeVar += (uInt)size_extra_field;
2011
2012         return err;
2013 }
2014
2015 /*
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.
2018  */
2019 extern int unzOpenCurrentFile( unzFile file ){
2020         int err = UNZ_OK;
2021         int Store;
2022         uInt iSizeVar;
2023         unz_s* s;
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 */
2027
2028         if ( file == NULL ) {
2029                 return UNZ_PARAMERROR;
2030         }
2031         s = (unz_s*)file;
2032         if ( !s->current_file_ok ) {
2033                 return UNZ_PARAMERROR;
2034         }
2035
2036         if ( s->pfile_in_zip_read != NULL ) {
2037                 unzCloseCurrentFile( file );
2038         }
2039
2040         if ( unzlocal_CheckCurrentFileCoherencyHeader( s,&iSizeVar,
2041                                                                                                    &offset_local_extrafield,&size_local_extrafield ) != UNZ_OK ) {
2042                 return UNZ_BADZIPFILE;
2043         }
2044
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;
2049         }
2050
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;
2055
2056         if ( pfile_in_zip_read_info->read_buffer == NULL ) {
2057                 free( pfile_in_zip_read_info );
2058                 return UNZ_INTERNALERROR;
2059         }
2060
2061         pfile_in_zip_read_info->stream_initialised = 0;
2062
2063         if ( ( s->cur_file_info.compression_method != 0 ) &&
2064                  ( s->cur_file_info.compression_method != Z_DEFLATED ) ) {
2065                 err = UNZ_BADZIPFILE;
2066         }
2067         Store = s->cur_file_info.compression_method == 0;
2068
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;
2075
2076         pfile_in_zip_read_info->stream.total_out = 0;
2077
2078         if ( !Store ) {
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;
2082
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;
2086                 }
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
2093                  */
2094         }
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 ;
2099
2100
2101         pfile_in_zip_read_info->pos_in_zipfile =
2102                 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
2103                 iSizeVar;
2104
2105         pfile_in_zip_read_info->stream.avail_in = (uInt)0;
2106
2107
2108         s->pfile_in_zip_read = pfile_in_zip_read_info;
2109         return UNZ_OK;
2110 }
2111
2112
2113 /*
2114    Read bytes from the current file.
2115    buf contain buffer where data must be copied
2116    len the size of buf.
2117
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)
2122  */
2123 extern int unzReadCurrentFile( unzFile file, void *buf, unsigned len ){
2124         int err = UNZ_OK;
2125         uInt iRead = 0;
2126         unz_s* s;
2127         file_in_zip_read_info_s* pfile_in_zip_read_info;
2128         if ( file == NULL ) {
2129                 return UNZ_PARAMERROR;
2130         }
2131         s = (unz_s*)file;
2132         pfile_in_zip_read_info = s->pfile_in_zip_read;
2133
2134         if ( pfile_in_zip_read_info == NULL ) {
2135                 return UNZ_PARAMERROR;
2136         }
2137
2138
2139         if ( ( pfile_in_zip_read_info->read_buffer == NULL ) ) {
2140                 return UNZ_END_OF_LIST_OF_FILE;
2141         }
2142         if ( len == 0 ) {
2143                 return 0;
2144         }
2145
2146         pfile_in_zip_read_info->stream.next_out = (Byte*)buf;
2147
2148         pfile_in_zip_read_info->stream.avail_out = (uInt)len;
2149
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;
2153         }
2154
2155         while ( pfile_in_zip_read_info->stream.avail_out > 0 )
2156         {
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;
2162                         }
2163                         if ( uReadThis == 0 ) {
2164                                 return UNZ_EOF;
2165                         }
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 ) {
2170                                         return UNZ_ERRNO;
2171                                 }
2172                         }
2173                         if ( fread( pfile_in_zip_read_info->read_buffer,uReadThis,1,
2174                                                 pfile_in_zip_read_info->file ) != 1 ) {
2175                                 return UNZ_ERRNO;
2176                         }
2177                         pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
2178
2179                         pfile_in_zip_read_info->rest_read_compressed -= uReadThis;
2180
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;
2184                 }
2185
2186                 if ( pfile_in_zip_read_info->compression_method == 0 ) {
2187                         uInt uDoCopy,i ;
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 ;
2191                         }
2192                         else{
2193                                 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
2194                         }
2195
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 );
2199
2200                         pfile_in_zip_read_info->crc32 = crc32( pfile_in_zip_read_info->crc32,
2201                                                                                                    pfile_in_zip_read_info->stream.next_out,
2202                                                                                                    uDoCopy );
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;
2209                         iRead += uDoCopy;
2210                 }
2211                 else
2212                 {
2213                         uLong uTotalOutBefore,uTotalOutAfter;
2214                         const Byte *bufBefore;
2215                         uLong uOutThis;
2216                         int flush = Z_SYNC_FLUSH;
2217
2218                         uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
2219                         bufBefore = pfile_in_zip_read_info->stream.next_out;
2220
2221                         /*
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))
2225                             flush = Z_FINISH;
2226                          */
2227                         err = inflate( &pfile_in_zip_read_info->stream,flush );
2228
2229                         uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
2230                         uOutThis = uTotalOutAfter - uTotalOutBefore;
2231
2232                         pfile_in_zip_read_info->crc32 =
2233                                 crc32( pfile_in_zip_read_info->crc32,bufBefore,
2234                                            (uInt)( uOutThis ) );
2235
2236                         pfile_in_zip_read_info->rest_read_uncompressed -=
2237                                 uOutThis;
2238
2239                         iRead += (uInt)( uTotalOutAfter - uTotalOutBefore );
2240
2241                         if ( err == Z_STREAM_END ) {
2242                                 return ( iRead == 0 ) ? UNZ_EOF : iRead;
2243                         }
2244                         if ( err != Z_OK ) {
2245                                 break;
2246                         }
2247                 }
2248         }
2249
2250         if ( err == Z_OK ) {
2251                 return iRead;
2252         }
2253         return err;
2254 }
2255
2256
2257 /*
2258    Give the current position in uncompressed data
2259  */
2260 extern long unztell( unzFile file ){
2261         unz_s* s;
2262         file_in_zip_read_info_s* pfile_in_zip_read_info;
2263         if ( file == NULL ) {
2264                 return UNZ_PARAMERROR;
2265         }
2266         s = (unz_s*)file;
2267         pfile_in_zip_read_info = s->pfile_in_zip_read;
2268
2269         if ( pfile_in_zip_read_info == NULL ) {
2270                 return UNZ_PARAMERROR;
2271         }
2272
2273         return (long)pfile_in_zip_read_info->stream.total_out;
2274 }
2275
2276
2277 /*
2278    return 1 if the end of file was reached, 0 elsewhere
2279  */
2280 extern int unzeof( unzFile file ){
2281         unz_s* s;
2282         file_in_zip_read_info_s* pfile_in_zip_read_info;
2283         if ( file == NULL ) {
2284                 return UNZ_PARAMERROR;
2285         }
2286         s = (unz_s*)file;
2287         pfile_in_zip_read_info = s->pfile_in_zip_read;
2288
2289         if ( pfile_in_zip_read_info == NULL ) {
2290                 return UNZ_PARAMERROR;
2291         }
2292
2293         if ( pfile_in_zip_read_info->rest_read_uncompressed == 0 ) {
2294                 return 1;
2295         }
2296         else{
2297                 return 0;
2298         }
2299 }
2300
2301
2302
2303 /*
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)
2307
2308    if buf==NULL, it return the size of the static extra field that can be read
2309
2310    if buf!=NULL, len is the size of the buffer, the extra header is copied in
2311     buf.
2312    the return value is the number of bytes copied in buf, or (if <0)
2313     the error code
2314  */
2315 extern int unzGetLocalExtrafield( unzFile file,void *buf,unsigned len ){
2316         unz_s* s;
2317         file_in_zip_read_info_s* pfile_in_zip_read_info;
2318         uInt read_now;
2319         uLong size_to_read;
2320
2321         if ( file == NULL ) {
2322                 return UNZ_PARAMERROR;
2323         }
2324         s = (unz_s*)file;
2325         pfile_in_zip_read_info = s->pfile_in_zip_read;
2326
2327         if ( pfile_in_zip_read_info == NULL ) {
2328                 return UNZ_PARAMERROR;
2329         }
2330
2331         size_to_read = ( pfile_in_zip_read_info->size_local_extrafield -
2332                                          pfile_in_zip_read_info->pos_local_extrafield );
2333
2334         if ( buf == NULL ) {
2335                 return (int)size_to_read;
2336         }
2337
2338         if ( len > size_to_read ) {
2339                 read_now = (uInt)size_to_read;
2340         }
2341         else{
2342                 read_now = (uInt)len ;
2343         }
2344
2345         if ( read_now == 0 ) {
2346                 return 0;
2347         }
2348
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 ) {
2352                 return UNZ_ERRNO;
2353         }
2354
2355         if ( fread( buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file ) != 1 ) {
2356                 return UNZ_ERRNO;
2357         }
2358
2359         return (int)read_now;
2360 }
2361
2362 /*
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
2365  */
2366 extern int unzCloseCurrentFile( unzFile file ){
2367         int err = UNZ_OK;
2368
2369         unz_s* s;
2370         file_in_zip_read_info_s* pfile_in_zip_read_info;
2371         if ( file == NULL ) {
2372                 return UNZ_PARAMERROR;
2373         }
2374         s = (unz_s*)file;
2375         pfile_in_zip_read_info = s->pfile_in_zip_read;
2376
2377         if ( pfile_in_zip_read_info == NULL ) {
2378                 return UNZ_PARAMERROR;
2379         }
2380
2381
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 ) {
2384                         err = UNZ_CRCERROR;
2385                 }
2386         }
2387
2388
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 );
2393         }
2394
2395         pfile_in_zip_read_info->stream_initialised = 0;
2396         free( pfile_in_zip_read_info );
2397
2398         s->pfile_in_zip_read = NULL;
2399
2400         return err;
2401 }
2402
2403
2404 /*
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
2408  */
2409 extern int unzGetGlobalComment( unzFile file, char *szComment, uLong uSizeBuf ){
2410         unz_s* s;
2411         uLong uReadThis ;
2412         if ( file == NULL ) {
2413                 return UNZ_PARAMERROR;
2414         }
2415         s = (unz_s*)file;
2416
2417         uReadThis = uSizeBuf;
2418         if ( uReadThis > s->gi.size_comment ) {
2419                 uReadThis = s->gi.size_comment;
2420         }
2421
2422         if ( fseek( s->file,s->central_pos + 22,SEEK_SET ) != 0 ) {
2423                 return UNZ_ERRNO;
2424         }
2425
2426         if ( uReadThis > 0 ) {
2427                 *szComment = '\0';
2428                 if ( fread( szComment,(uInt)uReadThis,1,s->file ) != 1 ) {
2429                         return UNZ_ERRNO;
2430                 }
2431         }
2432
2433         if ( ( szComment != NULL ) && ( uSizeBuf > s->gi.size_comment ) ) {
2434                 *( szComment + s->gi.size_comment ) = '\0';
2435         }
2436         return (int)uReadThis;
2437 }
2438
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
2442  */
2443
2444
2445 #ifdef DYNAMIC_CRC_TABLE
2446
2447 static int crc_table_empty = 1;
2448 static uLong crc_table[256];
2449 static void make_crc_table OF( (void) );
2450
2451 /*
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.
2454
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.
2462
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.
2470
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.
2474  */
2475 static void make_crc_table(){
2476         uLong c;
2477         int n, k;
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};
2481
2482         /* make exclusive-or pattern from polynomial (0xedb88320L) */
2483         poly = 0L;
2484         for ( n = 0; n < sizeof( p ) / sizeof( Byte ); n++ )
2485                 poly |= 1L << ( 31 - p[n] );
2486
2487         for ( n = 0; n < 256; n++ )
2488         {
2489                 c = (uLong)n;
2490                 for ( k = 0; k < 8; k++ )
2491                         c = c & 1 ? poly ^ ( c >> 1 ) : c >> 1;
2492                 crc_table[n] = c;
2493         }
2494         crc_table_empty = 0;
2495 }
2496 #else
2497 /* ========================================================================
2498  * Table of CRC-32's of all single-byte values (made by make_crc_table)
2499  */
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,
2552         0x2d02ef8dL
2553 };
2554 #endif
2555
2556 /* =========================================================================
2557  * This function can be used by asm versions of crc32()
2558  */
2559 const uLong * get_crc_table(){
2560 #ifdef DYNAMIC_CRC_TABLE
2561         if ( crc_table_empty ) {
2562                 make_crc_table();
2563         }
2564 #endif
2565         return (const uLong *)crc_table;
2566 }
2567
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 );
2573
2574 /* ========================================================================= */
2575 uLong crc32( uLong crc, const Byte *buf, uInt len ){
2576         if ( buf == Z_NULL ) {
2577                 return 0L;
2578         }
2579 #ifdef DYNAMIC_CRC_TABLE
2580         if ( crc_table_empty ) {
2581                 make_crc_table();
2582         }
2583 #endif
2584         crc = crc ^ 0xffffffffL;
2585         while ( len >= 8 )
2586         {
2587                 DO8( buf );
2588                 len -= 8;
2589         }
2590         if ( len ) {
2591                 do {
2592                         DO1( buf );
2593                 } while ( --len );
2594         }
2595         return crc ^ 0xffffffffL;
2596 }
2597
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
2601  */
2602
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.
2606  */
2607
2608 struct inflate_blocks_state;
2609 typedef struct inflate_blocks_state inflate_blocks_statef;
2610
2611 extern inflate_blocks_statef * inflate_blocks_new OF( (
2612                                                                                                                   z_streamp z,
2613                                                                                                                   check_func c, /* check function */
2614                                                                                                                   uInt w ) ); /* window size */
2615
2616 extern int inflate_blocks OF( (
2617                                                                   inflate_blocks_statef *,
2618                                                                   z_streamp,
2619                                                                   int ) ); /* initial return code */
2620
2621 extern void inflate_blocks_reset OF( (
2622                                                                                  inflate_blocks_statef *,
2623                                                                                  z_streamp,
2624                                                                                  uLong * ) ); /* check value on output */
2625
2626 extern int inflate_blocks_free OF( (
2627                                                                            inflate_blocks_statef *,
2628                                                                            z_streamp ) );
2629
2630 extern void inflate_set_dictionary OF( (
2631                                                                                    inflate_blocks_statef * s,
2632                                                                                    const Byte * d, /* dictionary */
2633                                                                                    uInt n ) ); /* dictionary length */
2634
2635 extern int inflate_blocks_sync_point OF( (
2636                                                                                          inflate_blocks_statef * s ) );
2637
2638 /* simplify the use of the inflate_huft type with some defines */
2639 #define exop word.what.Exop
2640 #define bits word.what.Bits
2641
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
2645 };
2646
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
2650  */
2651
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.
2655  */
2656
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). */
2659
2660 typedef struct inflate_huft_s inflate_huft;
2661
2662 struct inflate_huft_s {
2663         union {
2664                 struct {
2665                         Byte Exop;  /* number of extra bits or operation */
2666                         Byte Bits;  /* number of bits in this code or subcode */
2667                 } what;
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,
2671                                or table offset */
2672 };
2673
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. */
2679 #define MANY 1440
2680
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 */
2687
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 */
2698
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 */
2705
2706
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
2710  */
2711
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.
2715  */
2716
2717 struct inflate_codes_state;
2718 typedef struct inflate_codes_state inflate_codes_statef;
2719
2720 extern inflate_codes_statef *inflate_codes_new OF( (
2721                                                                                                            uInt, uInt,
2722                                                                                                            inflate_huft *, inflate_huft *,
2723                                                                                                            z_streamp ) );
2724
2725 extern int inflate_codes OF( (
2726                                                                  inflate_blocks_statef *,
2727                                                                  z_streamp,
2728                                                                  int ) );
2729
2730 extern void inflate_codes_free OF( (
2731                                                                            inflate_codes_statef *,
2732                                                                            z_streamp ) );
2733
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
2737  */
2738
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.
2742  */
2743
2744 #ifndef _INFUTIL_H
2745 #define _INFUTIL_H
2746
2747 typedef enum {
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 */
2757         BAD
2758 }               /* got a data error--stuck here */
2759 inflate_block_mode;
2760
2761 /* inflate blocks semi-private state */
2762 struct inflate_blocks_state {
2763
2764         /* mode */
2765         inflate_block_mode mode;    /* current inflate_block mode */
2766
2767         /* mode dependent information */
2768         union {
2769                 uInt left;      /* if STORED, bytes left to copy */
2770                 struct {
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 */
2777                 struct {
2778                         inflate_codes_statef
2779                         *codes;
2780                 } decode;       /* if CODES, current state */
2781         } sub;              /* submode */
2782         uInt last;          /* true if this block is the last block */
2783
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 */
2794
2795 };
2796
2797
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 ); }
2811 /*   output bytes */
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}
2820
2821 /* masks for lower bits (size given to avoid silly warnings with Visual C++) */
2822 extern uInt inflate_mask[17];
2823
2824 /* copy as much as possible from the sliding window to the output area */
2825 extern int inflate_flush OF( (
2826                                                                  inflate_blocks_statef *,
2827                                                                  z_streamp,
2828                                                                  int ) );
2829
2830 #endif
2831
2832
2833 /*
2834    Notes beyond the 1.93a appnote.txt:
2835
2836    1. Distance pointers never point before the beginning of the output
2837       stream.
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
2849       length.
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.
2876  */
2877
2878
2879 void inflate_blocks_reset( inflate_blocks_statef *s, z_streamp z, uLong *c ){
2880         if ( c != Z_NULL ) {
2881                 *c = s->check;
2882         }
2883         if ( s->mode == BTREE || s->mode == DTREE ) {
2884                 ZFREE( z, s->sub.trees.blens );
2885         }
2886         if ( s->mode == CODES ) {
2887                 inflate_codes_free( s->sub.decode.codes, z );
2888         }
2889         s->mode = TYPE;
2890         s->bitk = 0;
2891         s->bitb = 0;
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 );
2895         }
2896         Tracev( ( "inflate:   blocks reset\n" ) );
2897 }
2898
2899
2900 inflate_blocks_statef *inflate_blocks_new( z_streamp z, check_func c, uInt w ){
2901         inflate_blocks_statef *s;
2902
2903         if ( ( s = (inflate_blocks_statef *)ZALLOC
2904                                    ( z,1,sizeof( struct inflate_blocks_state ) ) ) == Z_NULL ) {
2905                 return s;
2906         }
2907         if ( ( s->hufts =
2908                            (inflate_huft *)ZALLOC( z, sizeof( inflate_huft ), MANY ) ) == Z_NULL ) {
2909                 ZFREE( z, s );
2910                 return Z_NULL;
2911         }
2912         if ( ( s->window = (Byte *)ZALLOC( z, 1, w ) ) == Z_NULL ) {
2913                 ZFREE( z, s->hufts );
2914                 ZFREE( z, s );
2915                 return Z_NULL;
2916         }
2917         s->end = s->window + w;
2918         s->checkfn = c;
2919         s->mode = TYPE;
2920         Tracev( ( "inflate:   blocks allocated\n" ) );
2921         inflate_blocks_reset( s, z, Z_NULL );
2922         return s;
2923 }
2924
2925
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 */
2934
2935         /* copy input/output information to locals (UPDATE macro restores) */
2936         LOAD
2937
2938         /* process input based on current state */
2939         while ( 1 ) switch ( s->mode )
2940                 {
2941                 case TYPE:
2942                         NEEDBITS( 3 )
2943                         t = (uInt)b & 7;
2944                         s->last = t & 1;
2945                         switch ( t >> 1 )
2946                         {
2947                         case 0:                     /* stored */
2948                                 Tracev( ( "inflate:     stored block%s\n",
2949                                                   s->last ? " (last)" : "" ) );
2950                                 DUMPBITS( 3 )
2951                                 t = k & 7;              /* go to byte boundary */
2952                                 DUMPBITS( t )
2953                                 s->mode = LENS;         /* get length of stored block */
2954                                 break;
2955                         case 1:                     /* fixed */
2956                                 Tracev( ( "inflate:     fixed codes block%s\n",
2957                                                   s->last ? " (last)" : "" ) );
2958                                 {
2959                                         uInt bl, bd;
2960                                         inflate_huft *tl, *td;
2961
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 ) {
2965                                                 r = Z_MEM_ERROR;
2966                                                 LEAVE
2967                                         }
2968                                 }
2969                                 DUMPBITS( 3 )
2970                                 s->mode = CODES;
2971                                 break;
2972                         case 2:                     /* dynamic */
2973                                 Tracev( ( "inflate:     dynamic codes block%s\n",
2974                                                   s->last ? " (last)" : "" ) );
2975                                 DUMPBITS( 3 )
2976                                 s->mode = TABLE;
2977                                 break;
2978                         case 3:                     /* illegal */
2979                                 DUMPBITS( 3 )
2980                                 s->mode = BAD;
2981                                 z->msg = (char*)"invalid block type";
2982                                 r = Z_DATA_ERROR;
2983                                 LEAVE
2984                         }
2985                         break;
2986                 case LENS:
2987                         NEEDBITS( 32 )
2988                         if ( ( ( ( ~b ) >> 16 ) & 0xffff ) != ( b & 0xffff ) ) {
2989                                 s->mode = BAD;
2990                                 z->msg = (char*)"invalid stored block lengths";
2991                                 r = Z_DATA_ERROR;
2992                                 LEAVE
2993                         }
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 );
2998                         break;
2999                 case STORED:
3000                         if ( n == 0 ) {
3001                                 LEAVE
3002                                 NEEDOUT
3003                                         t = s->sub.left;
3004                         }
3005                         if ( t > n ) {
3006                                 t = n;
3007                         }
3008                         if ( t > m ) {
3009                                 t = m;
3010                         }
3011                         zmemcpy( q, p, t );
3012                         p += t;  n -= t;
3013                         q += t;  m -= t;
3014                         if ( ( s->sub.left -= t ) != 0 ) {
3015                                 break;
3016                         }
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;
3021                         break;
3022                 case TABLE:
3023                         NEEDBITS( 14 )
3024                         s->sub.trees.table = t = (uInt)b & 0x3fff;
3025 #ifndef PKZIP_BUG_WORKAROUND
3026                         if ( ( t & 0x1f ) > 29 || ( ( t >> 5 ) & 0x1f ) > 29 ) {
3027                                 s->mode = BAD;
3028                                 z->msg = (char*)"too many length or distance symbols";
3029                                 r = Z_DATA_ERROR;
3030                                 LEAVE
3031                         }
3032 #endif
3033                         t = 258 + ( t & 0x1f ) + ( ( t >> 5 ) & 0x1f );
3034                         if ( ( s->sub.trees.blens = (uInt*)ZALLOC( z, t, sizeof( uInt ) ) ) == Z_NULL ) {
3035                                 r = Z_MEM_ERROR;
3036                                 LEAVE
3037                         }
3038                         DUMPBITS( 14 )
3039                         s->sub.trees.index = 0;
3040                         Tracev( ( "inflate:       table sizes ok\n" ) );
3041                         s->mode = BTREE;
3042                 case BTREE:
3043                         while ( s->sub.trees.index < 4 + ( s->sub.trees.table >> 10 ) )
3044                         {
3045                                 NEEDBITS( 3 )
3046                                 s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
3047                                 DUMPBITS( 3 )
3048                         }
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 );
3054                         if ( t != Z_OK ) {
3055                                 ZFREE( z, s->sub.trees.blens );
3056                                 r = t;
3057                                 if ( r == Z_DATA_ERROR ) {
3058                                         s->mode = BAD;
3059                                 }
3060                                 LEAVE
3061                         }
3062                         s->sub.trees.index = 0;
3063                         Tracev( ( "inflate:       bits tree ok\n" ) );
3064                         s->mode = DTREE;
3065                 case DTREE:
3066                         while ( t = s->sub.trees.table,
3067                                         s->sub.trees.index < 258 + ( t & 0x1f ) + ( ( t >> 5 ) & 0x1f ) )
3068                         {
3069                                 inflate_huft *h;
3070                                 uInt i, j, c;
3071
3072                                 t = s->sub.trees.bb;
3073                                 NEEDBITS( t )
3074                                 h = s->sub.trees.tb + ( (uInt)b & inflate_mask[t] );
3075                                 t = h->bits;
3076                                 c = h->base;
3077                                 if ( c < 16 ) {
3078                                         DUMPBITS( t )
3079                                         s->sub.trees.blens[s->sub.trees.index++] = c;
3080                                 }
3081                                 else /* c == 16..18 */
3082                                 {
3083                                         i = c == 18 ? 7 : c - 14;
3084                                         j = c == 18 ? 11 : 3;
3085                                         NEEDBITS( t + i )
3086                                         DUMPBITS( t )
3087                                         j += (uInt)b & inflate_mask[i];
3088                                         DUMPBITS( 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 );
3094                                                 s->mode = BAD;
3095                                                 z->msg = (char*)"invalid bit length repeat";
3096                                                 r = Z_DATA_ERROR;
3097                                                 LEAVE
3098                                         }
3099                                         c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
3100                                         do {
3101                                                 s->sub.trees.blens[i++] = c;
3102                                         } while ( --j );
3103                                         s->sub.trees.index = i;
3104                                 }
3105                         }
3106                         s->sub.trees.tb = Z_NULL;
3107                         {
3108                                 uInt bl, bd;
3109                                 inflate_huft *tl, *td;
3110                                 inflate_codes_statef *c;
3111
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,
3117                                                                                    s->hufts, z );
3118                                 ZFREE( z, s->sub.trees.blens );
3119                                 if ( t != Z_OK ) {
3120                                         if ( t == (uInt)Z_DATA_ERROR ) {
3121                                                 s->mode = BAD;
3122                                         }
3123                                         r = t;
3124                                         LEAVE
3125                                 }
3126                                 Tracev( ( "inflate:       trees ok\n" ) );
3127                                 if ( ( c = inflate_codes_new( bl, bd, tl, td, z ) ) == Z_NULL ) {
3128                                         r = Z_MEM_ERROR;
3129                                         LEAVE
3130                                 }
3131                                 s->sub.decode.codes = c;
3132                         }
3133                         s->mode = CODES;
3134                 case CODES:
3135                         UPDATE
3136                         if ( ( r = inflate_codes( s, z, r ) ) != Z_STREAM_END ) {
3137                                 return inflate_flush( s, z, r );
3138                         }
3139                         r = Z_OK;
3140                         inflate_codes_free( s->sub.decode.codes, z );
3141                         LOAD
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 ) ) ) );
3145                         if ( !s->last ) {
3146                                 s->mode = TYPE;
3147                                 break;
3148                         }
3149                         s->mode = DRY;
3150                 case DRY:
3151                         FLUSH
3152                         if ( s->read != s->write ) {
3153                                 LEAVE
3154                                 s->mode = DONE;
3155                         }
3156                 case DONE:
3157                         r = Z_STREAM_END;
3158                         LEAVE
3159                 case BAD: