uncrustify! now the code is only ugly on the *inside*
[xonotic/netradiant.git] / tools / quake3 / common / unzip.c
1 /*
2    Copyright (C) 1999-2007 id Software, Inc. and contributors.
3    For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5    This file is part of GtkRadiant.
6
7    GtkRadiant is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    GtkRadiant is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GtkRadiant; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 /*****************************************************************************
23 * name:         unzip.c
24 *
25 * desc:         IO on .zip files using portions of zlib
26 *
27 *
28 *****************************************************************************/
29
30 #include <stdlib.h>
31 #include <stdio.h>
32 #include <string.h>
33 #include "unzip.h"
34
35 // TTimo added for safe_malloc wrapping
36 #include "cmdlib.h"
37
38 /* unzip.h -- IO for uncompress .zip files using zlib
39    Version 0.15 beta, Mar 19th, 1998,
40
41    Copyright (C) 1998 Gilles Vollant
42
43    This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
44      WinZip, InfoZip tools and compatible.
45    Encryption and multi volume ZipFile (span) are not supported.
46    Old compressions used by old PKZip 1.x are not supported
47
48    THIS IS AN ALPHA VERSION. AT THIS STAGE OF DEVELOPPEMENT, SOMES API OR STRUCTURE
49    CAN CHANGE IN FUTURE VERSION !!
50    I WAIT FEEDBACK at mail info@winimage.com
51    Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
52
53    Condition of use and distribution are the same than zlib :
54
55    This software is provided 'as-is', without any express or implied
56    warranty.  In no event will the authors be held liable for any damages
57    arising from the use of this software.
58
59    Permission is granted to anyone to use this software for any purpose,
60    including commercial applications, and to alter it and redistribute it
61    freely, subject to the following restrictions:
62
63    1. The origin of this software must not be misrepresented; you must not
64      claim that you wrote the original software. If you use this software
65      in a product, an acknowledgment in the product documentation would be
66      appreciated but is not required.
67    2. Altered source versions must be plainly marked as such, and must not be
68      misrepresented as being the original software.
69    3. This notice may not be removed or altered from any source distribution.
70
71
72  */
73 /* for more info about .ZIP format, see
74       ftp://ftp.cdrom.com/pub/infozip/doc/appnote-970311-iz.zip
75    PkWare has also a specification at :
76       ftp://ftp.pkware.com/probdesc.zip */
77
78 /* zlib.h -- interface of the 'zlib' general purpose compression library
79    version 1.1.3, July 9th, 1998
80
81    Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
82
83    This software is provided 'as-is', without any express or implied
84    warranty.  In no event will the authors be held liable for any damages
85    arising from the use of this software.
86
87    Permission is granted to anyone to use this software for any purpose,
88    including commercial applications, and to alter it and redistribute it
89    freely, subject to the following restrictions:
90
91    1. The origin of this software must not be misrepresented; you must not
92      claim that you wrote the original software. If you use this software
93      in a product, an acknowledgment in the product documentation would be
94      appreciated but is not required.
95    2. Altered source versions must be plainly marked as such, and must not be
96      misrepresented as being the original software.
97    3. This notice may not be removed or altered from any source distribution.
98
99    Jean-loup Gailly        Mark Adler
100    jloup@gzip.org          madler@alumni.caltech.edu
101
102
103    The data format used by the zlib library is described by RFCs (Request for
104    Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
105    (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
106  */
107
108 /* zconf.h -- configuration of the zlib compression library
109  * Copyright (C) 1995-1998 Jean-loup Gailly.
110  * For conditions of distribution and use, see copyright notice in zlib.h
111  */
112
113
114 #ifndef _ZCONF_H
115 #define _ZCONF_H
116
117 /* Maximum value for memLevel in deflateInit2 */
118 #ifndef MAX_MEM_LEVEL
119 #  ifdef MAXSEG_64K
120 #    define MAX_MEM_LEVEL 8
121 #  else
122 #    define MAX_MEM_LEVEL 9
123 #  endif
124 #endif
125
126 /* Maximum value for windowBits in deflateInit2 and inflateInit2.
127  * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
128  * created by gzip. (Files created by minigzip can still be extracted by
129  * gzip.)
130  */
131 #ifndef MAX_WBITS
132 #  define MAX_WBITS   15 /* 32K LZ77 window */
133 #endif
134
135 /* The memory requirements for deflate are (in bytes):
136             (1 << (windowBits+2)) +  (1 << (memLevel+9))
137    that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
138    plus a few kilobytes for small objects. For example, if you want to reduce
139    the default memory requirements from 256K to 128K, compile with
140      make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
141    Of course this will generally degrade compression (there's no free lunch).
142
143    The memory requirements for inflate are (in bytes) 1 << windowBits
144    that is, 32K for windowBits=15 (default value) plus a few kilobytes
145    for small objects.
146  */
147
148 /* Type declarations */
149
150 #ifndef OF /* function prototypes */
151 #define OF( args )  args
152 #endif
153
154 typedef unsigned char Byte;   /* 8 bits */
155 typedef unsigned int uInt;    /* 16 bits or more */
156 typedef unsigned long uLong;  /* 32 bits or more */
157 typedef Byte    *voidp;
158
159 #ifndef SEEK_SET
160 #  define SEEK_SET        0       /* Seek from beginning of file.  */
161 #  define SEEK_CUR        1       /* Seek from current position.  */
162 #  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
163 #endif
164
165 #endif /* _ZCONF_H */
166
167 #define ZLIB_VERSION "1.1.3"
168
169 /*
170      The 'zlib' compression library provides in-memory compression and
171    decompression functions, including integrity checks of the uncompressed
172    data.  This version of the library supports only one compression method
173    (deflation) but other algorithms will be added later and will have the same
174    stream interface.
175
176      Compression can be done in a single step if the buffers are large
177    enough (for example if an input file is mmap'ed), or can be done by
178    repeated calls of the compression function.  In the latter case, the
179    application must provide more input and/or consume the output
180    (providing more output space) before each call.
181
182      The library also supports reading and writing files in gzip (.gz) format
183    with an interface similar to that of stdio.
184
185      The library does not install any signal handler. The decoder checks
186    the consistency of the compressed data, so the library should never
187    crash even in case of corrupted input.
188  */
189
190 /*
191    The application must update next_in and avail_in when avail_in has
192    dropped to zero. It must update next_out and avail_out when avail_out
193    has dropped to zero. The application must initialize zalloc, zfree and
194    opaque before calling the init function. All other fields are set by the
195    compression library and must not be updated by the application.
196
197    The opaque value provided by the application will be passed as the first
198    parameter for calls of zalloc and zfree. This can be useful for custom
199    memory management. The compression library attaches no meaning to the
200    opaque value.
201
202    zalloc must return Z_NULL if there is not enough memory for the object.
203    If zlib is used in a multi-threaded application, zalloc and zfree must be
204    thread safe.
205
206    On 16-bit systems, the functions zalloc and zfree must be able to allocate
207    exactly 65536 bytes, but will not be required to allocate more than this
208    if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
209    pointers returned by zalloc for objects of exactly 65536 bytes *must*
210    have their offset normalized to zero. The default allocation function
211    provided by this library ensures this (see zutil.c). To reduce memory
212    requirements and avoid any allocation of 64K objects, at the expense of
213    compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
214
215    The fields total_in and total_out can be used for statistics or
216    progress reports. After compression, total_in holds the total size of
217    the uncompressed data and may be saved for use in the decompressor
218    (particularly if the decompressor wants to decompress everything in
219    a single step).
220  */
221
222 /* constants */
223
224 #define Z_NO_FLUSH      0
225 #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
226 #define Z_SYNC_FLUSH    2
227 #define Z_FULL_FLUSH    3
228 #define Z_FINISH        4
229 /* Allowed flush values; see deflate() below for details */
230
231 #define Z_OK            0
232 #define Z_STREAM_END    1
233 #define Z_NEED_DICT     2
234 #define Z_ERRNO        ( -1 )
235 #define Z_STREAM_ERROR ( -2 )
236 #define Z_DATA_ERROR   ( -3 )
237 #define Z_MEM_ERROR    ( -4 )
238 #define Z_BUF_ERROR    ( -5 )
239 #define Z_VERSION_ERROR ( -6 )
240 /* Return codes for the compression/decompression functions. Negative
241  * values are errors, positive values are used for special but normal events.
242  */
243
244 #define Z_NO_COMPRESSION         0
245 #define Z_BEST_SPEED             1
246 #define Z_BEST_COMPRESSION       9
247 #define Z_DEFAULT_COMPRESSION  ( -1 )
248 /* compression levels */
249
250 #define Z_FILTERED            1
251 #define Z_HUFFMAN_ONLY        2
252 #define Z_DEFAULT_STRATEGY    0
253 /* compression strategy; see deflateInit2() below for details */
254
255 #define Z_BINARY   0
256 #define Z_ASCII    1
257 #define Z_UNKNOWN  2
258 /* Possible values of the data_type field */
259
260 #define Z_DEFLATED   8
261 /* The deflate compression method (the only one supported in this version) */
262
263 #define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
264
265 #define zlib_version zlibVersion()
266 /* for compatibility with versions < 1.0.2 */
267
268 /* basic functions */
269
270 const char * zlibVersion OF( (void) );
271 /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
272    If the first character differs, the library code actually used is
273    not compatible with the zlib.h header file used by the application.
274    This check is automatically made by deflateInit and inflateInit.
275  */
276
277 /*
278    int deflateInit OF((z_streamp strm, int level));
279
280      Initializes the internal stream state for compression. The fields
281    zalloc, zfree and opaque must be initialized before by the caller.
282    If zalloc and zfree are set to Z_NULL, deflateInit updates them to
283    use default allocation functions.
284
285      The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
286    1 gives best speed, 9 gives best compression, 0 gives no compression at
287    all (the input data is simply copied a block at a time).
288    Z_DEFAULT_COMPRESSION requests a default compromise between speed and
289    compression (currently equivalent to level 6).
290
291      deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
292    enough memory, Z_STREAM_ERROR if level is not a valid compression level,
293    Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
294    with the version assumed by the caller (ZLIB_VERSION).
295    msg is set to null if there is no error message.  deflateInit does not
296    perform any compression: this will be done by deflate().
297  */
298
299
300 int deflate OF( ( z_streamp strm, int flush ) );
301 /*
302     deflate compresses as much data as possible, and stops when the input
303    buffer becomes empty or the output buffer becomes full. It may introduce some
304    output latency (reading input without producing any output) except when
305    forced to flush.
306
307     The detailed semantics are as follows. deflate performs one or both of the
308    following actions:
309
310    - Compress more input starting at next_in and update next_in and avail_in
311     accordingly. If not all input can be processed (because there is not
312     enough room in the output buffer), next_in and avail_in are updated and
313     processing will resume at this point for the next call of deflate().
314
315    - Provide more output starting at next_out and update next_out and avail_out
316     accordingly. This action is forced if the parameter flush is non zero.
317     Forcing flush frequently degrades the compression ratio, so this parameter
318     should be set only when necessary (in interactive applications).
319     Some output may be provided even if flush is not set.
320
321    Before the call of deflate(), the application should ensure that at least
322    one of the actions is possible, by providing more input and/or consuming
323    more output, and updating avail_in or avail_out accordingly; avail_out
324    should never be zero before the call. The application can consume the
325    compressed output when it wants, for example when the output buffer is full
326    (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
327    and with zero avail_out, it must be called again after making room in the
328    output buffer because there might be more output pending.
329
330     If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
331    flushed to the output buffer and the output is aligned on a byte boundary, so
332    that the decompressor can get all input data available so far. (In particular
333    avail_in is zero after the call if enough output space has been provided
334    before the call.)  Flushing may degrade compression for some compression
335    algorithms and so it should be used only when necessary.
336
337     If flush is set to Z_FULL_FLUSH, all output is flushed as with
338    Z_SYNC_FLUSH, and the compression state is reset so that decompression can
339    restart from this point if previous compressed data has been damaged or if
340    random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
341    the compression.
342
343     If deflate returns with avail_out == 0, this function must be called again
344    with the same value of the flush parameter and more output space (updated
345    avail_out), until the flush is complete (deflate returns with non-zero
346    avail_out).
347
348     If the parameter flush is set to Z_FINISH, pending input is processed,
349    pending output is flushed and deflate returns with Z_STREAM_END if there
350    was enough output space; if deflate returns with Z_OK, this function must be
351    called again with Z_FINISH and more output space (updated avail_out) but no
352    more input data, until it returns with Z_STREAM_END or an error. After
353    deflate has returned Z_STREAM_END, the only possible operations on the
354    stream are deflateReset or deflateEnd.
355
356     Z_FINISH can be used immediately after deflateInit if all the compression
357    is to be done in a single step. In this case, avail_out must be at least
358    0.1% larger than avail_in plus 12 bytes.  If deflate does not return
359    Z_STREAM_END, then it must be called again as described above.
360
361     deflate() sets strm->adler to the adler32 checksum of all input read
362    so (that is, total_in bytes).
363
364     deflate() may update data_type if it can make a good guess about
365    the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
366    binary. This field is only for information purposes and does not affect
367    the compression algorithm in any manner.
368
369     deflate() returns Z_OK if some progress has been made (more input
370    processed or more output produced), Z_STREAM_END if all input has been
371    consumed and all output has been produced (only when flush is set to
372    Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
373    if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
374    (for example avail_in or avail_out was zero).
375  */
376
377
378 int deflateEnd OF( (z_streamp strm) );
379 /*
380      All dynamically allocated data structures for this stream are freed.
381    This function discards any unprocessed input and does not flush any
382    pending output.
383
384      deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
385    stream state was inconsistent, Z_DATA_ERROR if the stream was freed
386    prematurely (some input or output was discarded). In the error case,
387    msg may be set but then points to a static string (which must not be
388    deallocated).
389  */
390
391
392 /*
393    int inflateInit OF((z_streamp strm));
394
395      Initializes the internal stream state for decompression. The fields
396    next_in, avail_in, zalloc, zfree and opaque must be initialized before by
397    the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
398    value depends on the compression method), inflateInit determines the
399    compression method from the zlib header and allocates all data structures
400    accordingly; otherwise the allocation will be deferred to the first call of
401    inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
402    use default allocation functions.
403
404      inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
405    memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
406    version assumed by the caller.  msg is set to null if there is no error
407    message. inflateInit does not perform any decompression apart from reading
408    the zlib header if present: this will be done by inflate().  (So next_in and
409    avail_in may be modified, but next_out and avail_out are unchanged.)
410  */
411
412
413 int inflate OF( ( z_streamp strm, int flush ) );
414 /*
415     inflate decompresses as much data as possible, and stops when the input
416    buffer becomes empty or the output buffer becomes full. It may some
417    introduce some output latency (reading input without producing any output)
418    except when forced to flush.
419
420    The detailed semantics are as follows. inflate performs one or both of the
421    following actions:
422
423    - Decompress more input starting at next_in and update next_in and avail_in
424     accordingly. If not all input can be processed (because there is not
425     enough room in the output buffer), next_in is updated and processing
426     will resume at this point for the next call of inflate().
427
428    - Provide more output starting at next_out and update next_out and avail_out
429     accordingly.  inflate() provides as much output as possible, until there
430     is no more input data or no more space in the output buffer (see below
431     about the flush parameter).
432
433    Before the call of inflate(), the application should ensure that at least
434    one of the actions is possible, by providing more input and/or consuming
435    more output, and updating the next_* and avail_* values accordingly.
436    The application can consume the uncompressed output when it wants, for
437    example when the output buffer is full (avail_out == 0), or after each
438    call of inflate(). If inflate returns Z_OK and with zero avail_out, it
439    must be called again after making room in the output buffer because there
440    might be more output pending.
441
442     If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
443    output as possible to the output buffer. The flushing behavior of inflate is
444    not specified for values of the flush parameter other than Z_SYNC_FLUSH
445    and Z_FINISH, but the current implementation actually flushes as much output
446    as possible anyway.
447
448     inflate() should normally be called until it returns Z_STREAM_END or an
449    error. However if all decompression is to be performed in a single step
450    (a single call of inflate), the parameter flush should be set to
451    Z_FINISH. In this case all pending input is processed and all pending
452    output is flushed; avail_out must be large enough to hold all the
453    uncompressed data. (The size of the uncompressed data may have been saved
454    by the compressor for this purpose.) The next operation on this stream must
455    be inflateEnd to deallocate the decompression state. The use of Z_FINISH
456    is never required, but can be used to inform inflate that a faster routine
457    may be used for the single inflate() call.
458
459      If a preset dictionary is needed at this point (see inflateSetDictionary
460    below), inflate sets strm-adler to the adler32 checksum of the
461    dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise
462    it sets strm->adler to the adler32 checksum of all output produced
463    so (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
464    an error code as described below. At the end of the stream, inflate()
465    checks that its computed adler32 checksum is equal to that saved by the
466    compressor and returns Z_STREAM_END only if the checksum is correct.
467
468     inflate() returns Z_OK if some progress has been made (more input processed
469    or more output produced), Z_STREAM_END if the end of the compressed data has
470    been reached and all uncompressed output has been produced, Z_NEED_DICT if a
471    preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
472    corrupted (input stream not conforming to the zlib format or incorrect
473    adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
474    (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
475    enough memory, Z_BUF_ERROR if no progress is possible or if there was not
476    enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
477    case, the application may then call inflateSync to look for a good
478    compression block.
479  */
480
481
482 int inflateEnd OF( (z_streamp strm) );
483 /*
484      All dynamically allocated data structures for this stream are freed.
485    This function discards any unprocessed input and does not flush any
486    pending output.
487
488      inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
489    was inconsistent. In the error case, msg may be set but then points to a
490    static string (which must not be deallocated).
491  */
492
493 /* Advanced functions */
494
495 /*
496     The following functions are needed only in some special applications.
497  */
498
499 /*
500    int deflateInit2 OF((z_streamp strm,
501                                      int  level,
502                                      int  method,
503                                      int  windowBits,
504                                      int  memLevel,
505                                      int  strategy));
506
507      This is another version of deflateInit with more compression options. The
508    fields next_in, zalloc, zfree and opaque must be initialized before by
509    the caller.
510
511      The method parameter is the compression method. It must be Z_DEFLATED in
512    this version of the library.
513
514      The windowBits parameter is the base two logarithm of the window size
515    (the size of the history buffer).  It should be in the range 8..15 for this
516    version of the library. Larger values of this parameter result in better
517    compression at the expense of memory usage. The default value is 15 if
518    deflateInit is used instead.
519
520      The memLevel parameter specifies how much memory should be allocated
521    for the internal compression state. memLevel=1 uses minimum memory but
522    is slow and reduces compression ratio; memLevel=9 uses maximum memory
523    for optimal speed. The default value is 8. See zconf.h for total memory
524    usage as a function of windowBits and memLevel.
525
526      The strategy parameter is used to tune the compression algorithm. Use the
527    value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
528    filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
529    string match).  Filtered data consists mostly of small values with a
530    somewhat random distribution. In this case, the compression algorithm is
531    tuned to compress them better. The effect of Z_FILTERED is to force more
532    Huffman coding and less string matching; it is somewhat intermediate
533    between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
534    the compression ratio but not the correctness of the compressed output even
535    if it is not set appropriately.
536
537       deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
538    memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
539    method). msg is set to null if there is no error message.  deflateInit2 does
540    not perform any compression: this will be done by deflate().
541  */
542
543 int deflateSetDictionary OF( ( z_streamp strm,
544                                                            const Byte * dictionary,
545                                                            uInt dictLength ) );
546 /*
547      Initializes the compression dictionary from the given byte sequence
548    without producing any compressed output. This function must be called
549    immediately after deflateInit, deflateInit2 or deflateReset, before any
550    call of deflate. The compressor and decompressor must use exactly the same
551    dictionary (see inflateSetDictionary).
552
553      The dictionary should consist of strings (byte sequences) that are likely
554    to be encountered later in the data to be compressed, with the most commonly
555    used strings preferably put towards the end of the dictionary. Using a
556    dictionary is most useful when the data to be compressed is short and can be
557    predicted with good accuracy; the data can then be compressed better than
558    with the default empty dictionary.
559
560      Depending on the size of the compression data structures selected by
561    deflateInit or deflateInit2, a part of the dictionary may in effect be
562    discarded, for example if the dictionary is larger than the window size in
563    deflate or deflate2. Thus the strings most likely to be useful should be
564    put at the end of the dictionary, not at the front.
565
566      Upon return of this function, strm->adler is set to the Adler32 value
567    of the dictionary; the decompressor may later use this value to determine
568    which dictionary has been used by the compressor. (The Adler32 value
569    applies to the whole dictionary even if only a subset of the dictionary is
570    actually used by the compressor.)
571
572      deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
573    parameter is invalid (such as NULL dictionary) or the stream state is
574    inconsistent (for example if deflate has already been called for this stream
575    or if the compression method is bsort). deflateSetDictionary does not
576    perform any compression: this will be done by deflate().
577  */
578
579 int deflateCopy OF( ( z_streamp dest,
580                                           z_streamp source ) );
581 /*
582      Sets the destination stream as a complete copy of the source stream.
583
584      This function can be useful when several compression strategies will be
585    tried, for example when there are several ways of pre-processing the input
586    data with a filter. The streams that will be discarded should then be freed
587    by calling deflateEnd.  Note that deflateCopy duplicates the internal
588    compression state which can be quite large, so this strategy is slow and
589    can consume lots of memory.
590
591      deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
592    enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
593    (such as zalloc being NULL). msg is left unchanged in both source and
594    destination.
595  */
596
597 int deflateReset OF( (z_streamp strm) );
598 /*
599      This function is equivalent to deflateEnd followed by deflateInit,
600    but does not free and reallocate all the internal compression state.
601    The stream will keep the same compression level and any other attributes
602    that may have been set by deflateInit2.
603
604       deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
605    stream state was inconsistent (such as zalloc or state being NULL).
606  */
607
608 int deflateParams OF( ( z_streamp strm,
609                                                 int level,
610                                                 int strategy ) );
611 /*
612      Dynamically update the compression level and compression strategy.  The
613    interpretation of level and strategy is as in deflateInit2.  This can be
614    used to switch between compression and straight copy of the input data, or
615    to switch to a different kind of input data requiring a different
616    strategy. If the compression level is changed, the input available so far
617    is compressed with the old level (and may be flushed); the new level will
618    take effect only at the next call of deflate().
619
620      Before the call of deflateParams, the stream state must be set as for
621    a call of deflate(), since the currently available input may have to
622    be compressed and flushed. In particular, strm->avail_out must be non-zero.
623
624      deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
625    stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
626    if strm->avail_out was zero.
627  */
628
629 /*
630    int inflateInit2 OF((z_streamp strm,
631                                      int  windowBits));
632
633      This is another version of inflateInit with an extra parameter. The
634    fields next_in, avail_in, zalloc, zfree and opaque must be initialized
635    before by the caller.
636
637      The windowBits parameter is the base two logarithm of the maximum window
638    size (the size of the history buffer).  It should be in the range 8..15 for
639    this version of the library. The default value is 15 if inflateInit is used
640    instead. If a compressed stream with a larger window size is given as
641    input, inflate() will return with the error code Z_DATA_ERROR instead of
642    trying to allocate a larger window.
643
644       inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
645    memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
646    memLevel). msg is set to null if there is no error message.  inflateInit2
647    does not perform any decompression apart from reading the zlib header if
648    present: this will be done by inflate(). (So next_in and avail_in may be
649    modified, but next_out and avail_out are unchanged.)
650  */
651
652 int inflateSetDictionary OF( ( z_streamp strm,
653                                                            const Byte * dictionary,
654                                                            uInt dictLength ) );
655 /*
656      Initializes the decompression dictionary from the given uncompressed byte
657    sequence. This function must be called immediately after a call of inflate
658    if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
659    can be determined from the Adler32 value returned by this call of
660    inflate. The compressor and decompressor must use exactly the same
661    dictionary (see deflateSetDictionary).
662
663      inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
664    parameter is invalid (such as NULL dictionary) or the stream state is
665    inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
666    expected one (incorrect Adler32 value). inflateSetDictionary does not
667    perform any decompression: this will be done by subsequent calls of
668    inflate().
669  */
670
671 int inflateSync OF( (z_streamp strm) );
672 /*
673     Skips invalid compressed data until a full flush point (see above the
674    description of deflate with Z_FULL_FLUSH) can be found, or until all
675    available input is skipped. No output is provided.
676
677     inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
678    if no more input was provided, Z_DATA_ERROR if no flush point has been found,
679    or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
680    case, the application may save the current current value of total_in which
681    indicates where valid compressed data was found. In the error case, the
682    application may repeatedly call inflateSync, providing more input each time,
683    until success or end of the input data.
684  */
685
686 int inflateReset OF( (z_streamp strm) );
687 /*
688      This function is equivalent to inflateEnd followed by inflateInit,
689    but does not free and reallocate all the internal decompression state.
690    The stream will keep attributes that may have been set by inflateInit2.
691
692       inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
693    stream state was inconsistent (such as zalloc or state being NULL).
694  */
695
696
697 /* utility functions */
698
699 /*
700      The following utility functions are implemented on top of the
701    basic stream-oriented functions. To simplify the interface, some
702    default options are assumed (compression level and memory usage,
703    standard memory allocation functions). The source code of these
704    utility functions can easily be modified if you need special options.
705  */
706
707 int compress OF( ( Byte * dest,   uLong * destLen,
708                                    const Byte * source, uLong sourceLen ) );
709 /*
710      Compresses the source buffer into the destination buffer.  sourceLen is
711    the byte length of the source buffer. Upon entry, destLen is the total
712    size of the destination buffer, which must be at least 0.1% larger than
713    sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
714    compressed buffer.
715      This function can be used to compress a whole file at once if the
716    input file is mmap'ed.
717      compress returns Z_OK if success, Z_MEM_ERROR if there was not
718    enough memory, Z_BUF_ERROR if there was not enough room in the output
719    buffer.
720  */
721
722 int compress2 OF( ( Byte * dest,   uLong * destLen,
723                                         const Byte * source, uLong sourceLen,
724                                         int level ) );
725 /*
726      Compresses the source buffer into the destination buffer. The level
727    parameter has the same meaning as in deflateInit.  sourceLen is the byte
728    length of the source buffer. Upon entry, destLen is the total size of the
729    destination buffer, which must be at least 0.1% larger than sourceLen plus
730    12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
731
732      compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
733    memory, Z_BUF_ERROR if there was not enough room in the output buffer,
734    Z_STREAM_ERROR if the level parameter is invalid.
735  */
736
737 int uncompress OF( ( Byte * dest,   uLong * destLen,
738                                          const Byte * source, uLong sourceLen ) );
739 /*
740      Decompresses the source buffer into the destination buffer.  sourceLen is
741    the byte length of the source buffer. Upon entry, destLen is the total
742    size of the destination buffer, which must be large enough to hold the
743    entire uncompressed data. (The size of the uncompressed data must have
744    been saved previously by the compressor and transmitted to the decompressor
745    by some mechanism outside the scope of this compression library.)
746    Upon exit, destLen is the actual size of the compressed buffer.
747      This function can be used to decompress a whole file at once if the
748    input file is mmap'ed.
749
750      uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
751    enough memory, Z_BUF_ERROR if there was not enough room in the output
752    buffer, or Z_DATA_ERROR if the input data was corrupted.
753  */
754
755
756 typedef voidp gzFile;
757
758 gzFile gzopen  OF( ( const char *path, const char *mode ) );
759 /*
760      Opens a gzip (.gz) file for reading or writing. The mode parameter
761    is as in fopen ("rb" or "wb") but can also include a compression level
762    ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
763    Huffman only compression as in "wb1h". (See the description
764    of deflateInit2 for more information about the strategy parameter.)
765
766      gzopen can be used to read a file which is not in gzip format; in this
767    case gzread will directly read from the file without decompression.
768
769      gzopen returns NULL if the file could not be opened or if there was
770    insufficient memory to allocate the (de)compression state; errno
771    can be checked to distinguish the two cases (if errno is zero, the
772    zlib error is Z_MEM_ERROR).  */
773
774 gzFile gzdopen  OF( ( int fd, const char *mode ) );
775 /*
776      gzdopen() associates a gzFile with the file descriptor fd.  File
777    descriptors are obtained from calls like open, dup, creat, pipe or
778    fileno (in the file has been previously opened with fopen).
779    The mode parameter is as in gzopen.
780      The next call of gzclose on the returned gzFile will also close the
781    file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
782    descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
783      gzdopen returns NULL if there was insufficient memory to allocate
784    the (de)compression state.
785  */
786
787 int gzsetparams OF( ( gzFile file, int level, int strategy ) );
788 /*
789      Dynamically update the compression level or strategy. See the description
790    of deflateInit2 for the meaning of these parameters.
791      gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
792    opened for writing.
793  */
794
795 int gzread  OF( ( gzFile file, voidp buf, unsigned len ) );
796 /*
797      Reads the given number of uncompressed bytes from the compressed file.
798    If the input file was not in gzip format, gzread copies the given number
799    of bytes into the buffer.
800      gzread returns the number of uncompressed bytes actually read (0 for
801    end of file, -1 for error). */
802
803 int gzwrite OF( ( gzFile file,
804                                   const voidp buf, unsigned len ) );
805 /*
806      Writes the given number of uncompressed bytes into the compressed file.
807    gzwrite returns the number of uncompressed bytes actually written
808    (0 in case of error).
809  */
810
811 int gzprintf OF( ( gzFile file, const char *format, ... ) );
812 /*
813      Converts, formats, and writes the args to the compressed file under
814    control of the format string, as in fprintf. gzprintf returns the number of
815    uncompressed bytes actually written (0 in case of error).
816  */
817
818 int gzputs OF( ( gzFile file, const char *s ) );
819 /*
820       Writes the given null-terminated string to the compressed file, excluding
821    the terminating null character.
822       gzputs returns the number of characters written, or -1 in case of error.
823  */
824
825 char * gzgets OF( ( gzFile file, char *buf, int len ) );
826 /*
827       Reads bytes from the compressed file until len-1 characters are read, or
828    a newline character is read and transferred to buf, or an end-of-file
829    condition is encountered.  The string is then terminated with a null
830    character.
831       gzgets returns buf, or Z_NULL in case of error.
832  */
833
834 int gzputc OF( ( gzFile file, int c ) );
835 /*
836       Writes c, converted to an unsigned char, into the compressed file.
837    gzputc returns the value that was written, or -1 in case of error.
838  */
839
840 int gzgetc OF( (gzFile file) );
841 /*
842       Reads one byte from the compressed file. gzgetc returns this byte
843    or -1 in case of end of file or error.
844  */
845
846 int gzflush OF( ( gzFile file, int flush ) );
847 /*
848      Flushes all pending output into the compressed file. The parameter
849    flush is as in the deflate() function. The return value is the zlib
850    error number (see function gzerror below). gzflush returns Z_OK if
851    the flush parameter is Z_FINISH and all output could be flushed.
852      gzflush should be called only when strictly necessary because it can
853    degrade compression.
854  */
855
856 long gzseek OF( ( gzFile file,
857                                   long offset, int whence ) );
858 /*
859       Sets the starting position for the next gzread or gzwrite on the
860    given compressed file. The offset represents a number of bytes in the
861    uncompressed data stream. The whence parameter is defined as in lseek(2);
862    the value SEEK_END is not supported.
863      If the file is opened for reading, this function is emulated but can be
864    extremely slow. If the file is opened for writing, only forward seeks are
865    supported; gzseek then compresses a sequence of zeroes up to the new
866    starting position.
867
868       gzseek returns the resulting offset location as measured in bytes from
869    the beginning of the uncompressed stream, or -1 in case of error, in
870    particular if the file is opened for writing and the new starting position
871    would be before the current position.
872  */
873
874 int gzrewind OF( (gzFile file) );
875 /*
876      Rewinds the given file. This function is supported only for reading.
877
878    gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
879  */
880
881 long gztell OF( (gzFile file) );
882 /*
883      Returns the starting position for the next gzread or gzwrite on the
884    given compressed file. This position represents a number of bytes in the
885    uncompressed data stream.
886
887    gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
888  */
889
890 int gzeof OF( (gzFile file) );
891 /*
892      Returns 1 when EOF has previously been detected reading the given
893    input stream, otherwise zero.
894  */
895
896 int gzclose OF( (gzFile file) );
897 /*
898      Flushes all pending output if necessary, closes the compressed file
899    and deallocates all the (de)compression state. The return value is the zlib
900    error number (see function gzerror below).
901  */
902
903 const char * gzerror OF( ( gzFile file, int *errnum ) );
904 /*
905      Returns the error message for the last error which occurred on the
906    given compressed file. errnum is set to zlib error number. If an
907    error occurred in the file system and not in the compression library,
908    errnum is set to Z_ERRNO and the application may consult errno
909    to get the exact error code.
910  */
911
912 /* checksum functions */
913
914 /*
915      These functions are not related to compression but are exported
916    anyway because they might be useful in applications using the
917    compression library.
918  */
919
920 uLong adler32 OF( ( uLong adler, const Byte * buf, uInt len ) );
921
922 /*
923      Update a running Adler-32 checksum with the bytes buf[0..len-1] and
924    return the updated checksum. If buf is NULL, this function returns
925    the required initial value for the checksum.
926    An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
927    much faster. Usage example:
928
929      uLong adler = adler32(0L, Z_NULL, 0);
930
931      while (read_buffer(buffer, length) != EOF) {
932        adler = adler32(adler, buffer, length);
933      }
934      if (adler != original_adler) error();
935  */
936
937 uLong crc32   OF( ( uLong crc, const Byte * buf, uInt len ) );
938 /*
939      Update a running crc with the bytes buf[0..len-1] and return the updated
940    crc. If buf is NULL, this function returns the required initial value
941    for the crc. Pre- and post-conditioning (one's complement) is performed
942    within this function so it shouldn't be done by the application.
943    Usage example:
944
945      uLong crc = crc32(0L, Z_NULL, 0);
946
947      while (read_buffer(buffer, length) != EOF) {
948        crc = crc32(crc, buffer, length);
949      }
950      if (crc != original_crc) error();
951  */
952
953 // private stuff to not include cmdlib.h
954 /*
955    ============================================================================
956
957                     BYTE ORDER FUNCTIONS
958
959    ============================================================================
960  */
961
962 #ifdef _SGI_SOURCE
963 #define __BIG_ENDIAN__
964 #endif
965
966 #ifdef __BIG_ENDIAN__
967
968 short   __LittleShort( short l ){
969         byte b1,b2;
970
971         b1 = l & 255;
972         b2 = ( l >> 8 ) & 255;
973
974         return ( b1 << 8 ) + b2;
975 }
976
977 short   __BigShort( short l ){
978         return l;
979 }
980
981
982 int    __LittleLong( int l ){
983         byte b1,b2,b3,b4;
984
985         b1 = l & 255;
986         b2 = ( l >> 8 ) & 255;
987         b3 = ( l >> 16 ) & 255;
988         b4 = ( l >> 24 ) & 255;
989
990         return ( (int)b1 << 24 ) + ( (int)b2 << 16 ) + ( (int)b3 << 8 ) + b4;
991 }
992
993 int    __BigLong( int l ){
994         return l;
995 }
996
997
998 float   __LittleFloat( float l ){
999         union {byte b[4]; float f; } in, out;
1000
1001         in.f = l;
1002         out.b[0] = in.b[3];
1003         out.b[1] = in.b[2];
1004         out.b[2] = in.b[1];
1005         out.b[3] = in.b[0];
1006
1007         return out.f;
1008 }
1009
1010 float   __BigFloat( float l ){
1011         return l;
1012 }
1013
1014
1015 #else
1016
1017
1018 short   __BigShort( short l ){
1019         byte b1,b2;
1020
1021         b1 = l & 255;
1022         b2 = ( l >> 8 ) & 255;
1023
1024         return ( b1 << 8 ) + b2;
1025 }
1026
1027 short   __LittleShort( short l ){
1028         return l;
1029 }
1030
1031
1032 int    __BigLong( int l ){
1033         byte b1,b2,b3,b4;
1034
1035         b1 = l & 255;
1036         b2 = ( l >> 8 ) & 255;
1037         b3 = ( l >> 16 ) & 255;
1038         b4 = ( l >> 24 ) & 255;
1039
1040         return ( (int)b1 << 24 ) + ( (int)b2 << 16 ) + ( (int)b3 << 8 ) + b4;
1041 }
1042
1043 int    __LittleLong( int l ){
1044         return l;
1045 }
1046
1047 float   __BigFloat( float l ){
1048         union {byte b[4]; float f; } in, out;
1049
1050         in.f = l;
1051         out.b[0] = in.b[3];
1052         out.b[1] = in.b[2];
1053         out.b[2] = in.b[1];
1054         out.b[3] = in.b[0];
1055
1056         return out.f;
1057 }
1058
1059 float   __LittleFloat( float l ){
1060         return l;
1061 }
1062
1063
1064
1065 #endif
1066
1067
1068
1069
1070 /* various hacks, don't look :) */
1071
1072 /* deflateInit and inflateInit are macros to allow checking the zlib version
1073  * and the compiler's view of z_stream:
1074  */
1075 int deflateInit_ OF( ( z_streamp strm, int level,
1076                                            const char *version, int stream_size ) );
1077 int inflateInit_ OF( ( z_streamp strm,
1078                                            const char *version, int stream_size ) );
1079 int deflateInit2_ OF( ( z_streamp strm, int level, int method,
1080                                                 int windowBits, int memLevel,
1081                                                 int strategy, const char *version,
1082                                                 int stream_size ) );
1083 int inflateInit2_ OF( ( z_streamp strm, int windowBits,
1084                                                 const char *version, int stream_size ) );
1085 #define deflateInit( strm, level ) \
1086         deflateInit_( ( strm ), ( level ),       ZLIB_VERSION, sizeof( z_stream ) )
1087 #define inflateInit( strm )     \
1088         inflateInit_( ( strm ),                ZLIB_VERSION, sizeof( z_stream ) )
1089 #define deflateInit2( strm, level, method, windowBits, memLevel, strategy )     \
1090         deflateInit2_( ( strm ),( level ),( method ),( windowBits ),( memLevel ), \
1091                                    ( strategy ),           ZLIB_VERSION, sizeof( z_stream ) )
1092 #define inflateInit2( strm, windowBits ) \
1093         inflateInit2_( ( strm ), ( windowBits ), ZLIB_VERSION, sizeof( z_stream ) )
1094
1095
1096 const char   * zError           OF( (int err) );
1097 int inflateSyncPoint OF( (z_streamp z) );
1098 const uLong * get_crc_table    OF( (void) );
1099
1100 typedef unsigned char uch;
1101 typedef unsigned short ush;
1102 typedef unsigned long ulg;
1103
1104 extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
1105 /* (size given to avoid silly warnings with Visual C++) */
1106
1107 #define ERR_MSG( err ) z_errmsg[Z_NEED_DICT - ( err )]
1108
1109 #define ERR_RETURN( strm,err ) \
1110         return ( strm->msg = (char*)ERR_MSG( err ), ( err ) )
1111 /* To be used only when the state is known to be valid */
1112
1113 /* common constants */
1114
1115 #ifndef DEF_WBITS
1116 #  define DEF_WBITS MAX_WBITS
1117 #endif
1118 /* default windowBits for decompression. MAX_WBITS is for compression only */
1119
1120 #if MAX_MEM_LEVEL >= 8
1121 #  define DEF_MEM_LEVEL 8
1122 #else
1123 #  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
1124 #endif
1125 /* default memLevel */
1126
1127 #define STORED_BLOCK 0
1128 #define STATIC_TREES 1
1129 #define DYN_TREES    2
1130 /* The three kinds of block type */
1131
1132 #define MIN_MATCH  3
1133 #define MAX_MATCH  258
1134 /* The minimum and maximum match lengths */
1135
1136 #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
1137
1138 /* target dependencies */
1139
1140 /* Common defaults */
1141
1142 #ifndef OS_CODE
1143 #  define OS_CODE  0x03  /* assume Unix */
1144 #endif
1145
1146 #ifndef F_OPEN
1147 #  define F_OPEN( name, mode ) fopen( ( name ), ( mode ) )
1148 #endif
1149
1150 /* functions */
1151
1152 #ifdef HAVE_STRERROR
1153 extern char *strerror OF( (int) );
1154 #  define zstrerror( errnum ) strerror( errnum )
1155 #else
1156 #  define zstrerror( errnum ) ""
1157 #endif
1158
1159 #define zmemcpy memcpy
1160 #define zmemcmp memcmp
1161 #define zmemzero( dest, len ) memset( dest, 0, len )
1162
1163 /* Diagnostic functions */
1164 #ifdef _ZIP_DEBUG_
1165 int z_verbose = 0;
1166 #  define Assert( cond,msg ) assert( cond );
1167 //{if(!(cond)) Sys_Error(msg);}
1168 #  define Trace( x ) {if ( z_verbose >= 0 ) {Sys_Error x ; }}
1169 #  define Tracev( x ) {if ( z_verbose > 0 ) {Sys_Error x ; }}
1170 #  define Tracevv( x ) {if ( z_verbose > 1 ) {Sys_Error x ; }}
1171 #  define Tracec( c,x ) {if ( z_verbose > 0 && ( c ) ) {Sys_Error x ; }}
1172 #  define Tracecv( c,x ) {if ( z_verbose > 1 && ( c ) ) {Sys_Error x ; }}
1173 #else
1174 #  define Assert( cond,msg )
1175 #  define Trace( x )
1176 #  define Tracev( x )
1177 #  define Tracevv( x )
1178 #  define Tracec( c,x )
1179 #  define Tracecv( c,x )
1180 #endif
1181
1182
1183 typedef uLong ( *check_func ) OF ( ( uLong check, const Byte * buf, uInt len ) );
1184 voidp zcalloc OF( ( voidp opaque, unsigned items, unsigned size ) );
1185 void zcfree  OF( ( voidp opaque, voidp ptr ) );
1186
1187 #define ZALLOC( strm, items, size )     \
1188         ( *( ( strm )->zalloc ) )( ( strm )->opaque, ( items ), ( size ) )
1189 #define ZFREE( strm, addr )  ( *( ( strm )->zfree ) )( ( strm )->opaque, (voidp)( addr ) )
1190 #define TRY_FREE( s, p ) {if ( p ) {ZFREE( s, p ); }}
1191
1192
1193 #if !defined( unix ) && !defined( CASESENSITIVITYDEFAULT_YES ) && \
1194         !defined( CASESENSITIVITYDEFAULT_NO )
1195 #define CASESENSITIVITYDEFAULT_NO
1196 #endif
1197
1198
1199 #ifndef UNZ_BUFSIZE
1200 #define UNZ_BUFSIZE ( 65536 )
1201 #endif
1202
1203 #ifndef UNZ_MAXFILENAMEINZIP
1204 #define UNZ_MAXFILENAMEINZIP ( 256 )
1205 #endif
1206
1207 #ifndef ALLOC
1208 # define ALLOC( size ) ( safe_malloc( size ) )
1209 #endif
1210 #ifndef TRYFREE
1211 # define TRYFREE( p ) {if ( p ) {free( p ); }}
1212 #endif
1213
1214 #define SIZECENTRALDIRITEM ( 0x2e )
1215 #define SIZEZIPLOCALHEADER ( 0x1e )
1216
1217
1218
1219 /* ===========================================================================
1220      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
1221    for end of file.
1222    IN assertion: the stream s has been sucessfully opened for reading.
1223  */
1224
1225 /*
1226    static int unzlocal_getByte(FILE *fin,int *pi)
1227    {
1228     unsigned char c;
1229     int err = fread(&c, 1, 1, fin);
1230     if (err==1)
1231     {
1232    *pi = (int)c;
1233         return UNZ_OK;
1234     }
1235     else
1236     {
1237         if (ferror(fin))
1238             return UNZ_ERRNO;
1239         else
1240             return UNZ_EOF;
1241     }
1242    }
1243  */
1244
1245 /* ===========================================================================
1246    Reads a long in LSB order from the given gz_stream. Sets
1247  */
1248 static int unzlocal_getShort( FILE* fin, uLong *pX ){
1249         short v;
1250
1251         fread( &v, sizeof( v ), 1, fin );
1252
1253         *pX = __LittleShort( v );
1254         return UNZ_OK;
1255
1256 /*
1257     uLong x ;
1258     int i;
1259     int err;
1260
1261     err = unzlocal_getByte(fin,&i);
1262     x = (uLong)i;
1263
1264     if (err==UNZ_OK)
1265         err = unzlocal_getByte(fin,&i);
1266     x += ((uLong)i)<<8;
1267
1268     if (err==UNZ_OK)
1269    *pX = x;
1270     else
1271    *pX = 0;
1272     return err;
1273  */
1274 }
1275
1276 static int unzlocal_getLong( FILE *fin, uLong *pX ){
1277         int v;
1278
1279         fread( &v, sizeof( v ), 1, fin );
1280
1281         *pX = __LittleLong( v );
1282         return UNZ_OK;
1283
1284 /*
1285     uLong x ;
1286     int i;
1287     int err;
1288
1289     err = unzlocal_getByte(fin,&i);
1290     x = (uLong)i;
1291
1292     if (err==UNZ_OK)
1293         err = unzlocal_getByte(fin,&i);
1294     x += ((uLong)i)<<8;
1295
1296     if (err==UNZ_OK)
1297         err = unzlocal_getByte(fin,&i);
1298     x += ((uLong)i)<<16;
1299
1300     if (err==UNZ_OK)
1301         err = unzlocal_getByte(fin,&i);
1302     x += ((uLong)i)<<24;
1303
1304     if (err==UNZ_OK)
1305    *pX = x;
1306     else
1307    *pX = 0;
1308     return err;
1309  */
1310 }
1311
1312
1313 /* My own strcmpi / strcasecmp */
1314 static int strcmpcasenosensitive_internal( const char* fileName1,const char* fileName2 ){
1315         for (;; )
1316         {
1317                 char c1 = *( fileName1++ );
1318                 char c2 = *( fileName2++ );
1319                 if ( ( c1 >= 'a' ) && ( c1 <= 'z' ) ) {
1320                         c1 -= 0x20;
1321                 }
1322                 if ( ( c2 >= 'a' ) && ( c2 <= 'z' ) ) {
1323                         c2 -= 0x20;
1324                 }
1325                 if ( c1 == '\0' ) {
1326                         return ( ( c2 == '\0' ) ? 0 : -1 );
1327                 }
1328                 if ( c2 == '\0' ) {
1329                         return 1;
1330                 }
1331                 if ( c1 < c2 ) {
1332                         return -1;
1333                 }
1334                 if ( c1 > c2 ) {
1335                         return 1;
1336                 }
1337         }
1338 }
1339
1340
1341 #ifdef  CASESENSITIVITYDEFAULT_NO
1342 #define CASESENSITIVITYDEFAULTVALUE 2
1343 #else
1344 #define CASESENSITIVITYDEFAULTVALUE 1
1345 #endif
1346
1347 #ifndef STRCMPCASENOSENTIVEFUNCTION
1348 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
1349 #endif
1350
1351 /*
1352    Compare two filename (fileName1,fileName2).
1353    If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
1354    If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
1355                                                                 or strcasecmp)
1356    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
1357         (like 1 on Unix, 2 on Windows)
1358
1359  */
1360 extern int unzStringFileNameCompare( const char* fileName1,const char* fileName2,int iCaseSensitivity ){
1361         if ( iCaseSensitivity == 0 ) {
1362                 iCaseSensitivity = CASESENSITIVITYDEFAULTVALUE;
1363         }
1364
1365         if ( iCaseSensitivity == 1 ) {
1366                 return strcmp( fileName1,fileName2 );
1367         }
1368
1369         return STRCMPCASENOSENTIVEFUNCTION( fileName1,fileName2 );
1370 }
1371
1372 #define BUFREADCOMMENT ( 0x400 )
1373
1374 /*
1375    Locate the Central directory of a zipfile (at the end, just before
1376     the global comment)
1377  */
1378 static uLong unzlocal_SearchCentralDir( FILE *fin ){
1379         unsigned char* buf;
1380         uLong uSizeFile;
1381         uLong uBackRead;
1382         uLong uMaxBack = 0xffff; /* maximum size of global comment */
1383         uLong uPosFound = 0;
1384
1385         if ( fseek( fin,0,SEEK_END ) != 0 ) {
1386                 return 0;
1387         }
1388
1389
1390         uSizeFile = ftell( fin );
1391
1392         if ( uMaxBack > uSizeFile ) {
1393                 uMaxBack = uSizeFile;
1394         }
1395
1396         buf = (unsigned char*)safe_malloc( BUFREADCOMMENT + 4 );
1397         if ( buf == NULL ) {
1398                 return 0;
1399         }
1400
1401         uBackRead = 4;
1402         while ( uBackRead < uMaxBack )
1403         {
1404                 uLong uReadSize,uReadPos ;
1405                 int i;
1406                 if ( uBackRead + BUFREADCOMMENT > uMaxBack ) {
1407                         uBackRead = uMaxBack;
1408                 }
1409                 else{
1410                         uBackRead += BUFREADCOMMENT;
1411                 }
1412                 uReadPos = uSizeFile - uBackRead ;
1413
1414                 uReadSize = ( ( BUFREADCOMMENT + 4 ) < ( uSizeFile - uReadPos ) ) ?
1415                                         ( BUFREADCOMMENT + 4 ) : ( uSizeFile - uReadPos );
1416                 if ( fseek( fin,uReadPos,SEEK_SET ) != 0 ) {
1417                         break;
1418                 }
1419
1420                 if ( fread( buf,(uInt)uReadSize,1,fin ) != 1 ) {
1421                         break;
1422                 }
1423
1424                 for ( i = (int)uReadSize - 3; ( i-- ) > 0; )
1425                         if ( ( ( *( buf + i ) ) == 0x50 ) && ( ( *( buf + i + 1 ) ) == 0x4b ) &&
1426                                  ( ( *( buf + i + 2 ) ) == 0x05 ) && ( ( *( buf + i + 3 ) ) == 0x06 ) ) {
1427                                 uPosFound = uReadPos + i;
1428                                 break;
1429                         }
1430
1431                 if ( uPosFound != 0 ) {
1432                         break;
1433                 }
1434         }
1435         free( buf );
1436         return uPosFound;
1437 }
1438
1439 extern unzFile unzReOpen( const char* path, unzFile file ){
1440         unz_s *s;
1441         FILE * fin;
1442
1443         fin = fopen( path,"rb" );
1444         if ( fin == NULL ) {
1445                 return NULL;
1446         }
1447
1448         s = (unz_s*)safe_malloc( sizeof( unz_s ) );
1449         memcpy( s, (unz_s*)file, sizeof( unz_s ) );
1450
1451         s->file = fin;
1452         return (unzFile)s;
1453 }
1454
1455 /*
1456    Open a Zip file. path contain the full pathname (by example,
1457      on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
1458      "zlib/zlib109.zip".
1459      If the zipfile cannot be opened (file don't exist or in not valid), the
1460        return value is NULL.
1461      Else, the return value is a unzFile Handle, usable with other function
1462        of this unzip package.
1463  */
1464 extern unzFile unzOpen( const char* path ){
1465         unz_s us;
1466         unz_s *s;
1467         uLong central_pos,uL;
1468         FILE * fin ;
1469
1470         uLong number_disk;          /* number of the current dist, used for
1471                                        spaning ZIP, unsupported, always 0*/
1472         uLong number_disk_with_CD;  /* number the the disk with central dir, used
1473                                        for spaning ZIP, unsupported, always 0*/
1474         uLong number_entry_CD;      /* total number of entries in
1475                                        the central dir
1476                                        (same than number_entry on nospan) */
1477
1478         int err = UNZ_OK;
1479
1480         fin = fopen( path,"rb" );
1481         if ( fin == NULL ) {
1482                 return NULL;
1483         }
1484
1485         central_pos = unzlocal_SearchCentralDir( fin );
1486         if ( central_pos == 0 ) {
1487                 err = UNZ_ERRNO;
1488         }
1489
1490         if ( fseek( fin,central_pos,SEEK_SET ) != 0 ) {
1491                 err = UNZ_ERRNO;
1492         }
1493
1494         /* the signature, already checked */
1495         if ( unzlocal_getLong( fin,&uL ) != UNZ_OK ) {
1496                 err = UNZ_ERRNO;
1497         }
1498
1499         /* number of this disk */
1500         if ( unzlocal_getShort( fin,&number_disk ) != UNZ_OK ) {
1501                 err = UNZ_ERRNO;
1502         }
1503
1504         /* number of the disk with the start of the central directory */
1505         if ( unzlocal_getShort( fin,&number_disk_with_CD ) != UNZ_OK ) {
1506                 err = UNZ_ERRNO;
1507         }
1508
1509         /* total number of entries in the central dir on this disk */
1510         if ( unzlocal_getShort( fin,&us.gi.number_entry ) != UNZ_OK ) {
1511                 err = UNZ_ERRNO;
1512         }
1513
1514         /* total number of entries in the central dir */
1515         if ( unzlocal_getShort( fin,&number_entry_CD ) != UNZ_OK ) {
1516                 err = UNZ_ERRNO;
1517         }
1518
1519         if ( ( number_entry_CD != us.gi.number_entry ) ||
1520                  ( number_disk_with_CD != 0 ) ||
1521                  ( number_disk != 0 ) ) {
1522                 err = UNZ_BADZIPFILE;
1523         }
1524
1525         /* size of the central directory */
1526         if ( unzlocal_getLong( fin,&us.size_central_dir ) != UNZ_OK ) {
1527                 err = UNZ_ERRNO;
1528         }
1529
1530         /* offset of start of central directory with respect to the
1531               starting disk number */
1532         if ( unzlocal_getLong( fin,&us.offset_central_dir ) != UNZ_OK ) {
1533                 err = UNZ_ERRNO;
1534         }
1535
1536         /* zipfile comment length */
1537         if ( unzlocal_getShort( fin,&us.gi.size_comment ) != UNZ_OK ) {
1538                 err = UNZ_ERRNO;
1539         }
1540
1541         if ( ( central_pos < us.offset_central_dir + us.size_central_dir ) &&
1542                  ( err == UNZ_OK ) ) {
1543                 err = UNZ_BADZIPFILE;
1544         }
1545
1546         if ( err != UNZ_OK ) {
1547                 fclose( fin );
1548                 return NULL;
1549         }
1550
1551         us.file = fin;
1552         us.byte_before_the_zipfile = central_pos -
1553                                                                  ( us.offset_central_dir + us.size_central_dir );
1554         us.central_pos = central_pos;
1555         us.pfile_in_zip_read = NULL;
1556
1557
1558         s = (unz_s*)safe_malloc( sizeof( unz_s ) );
1559         *s = us;
1560 //      unzGoToFirstFile((unzFile)s);
1561         return (unzFile)s;
1562 }
1563
1564
1565 /*
1566    Close a ZipFile opened with unzipOpen.
1567    If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
1568     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
1569    return UNZ_OK if there is no problem. */
1570 extern int unzClose( unzFile file ){
1571         unz_s* s;
1572         if ( file == NULL ) {
1573                 return UNZ_PARAMERROR;
1574         }
1575         s = (unz_s*)file;
1576
1577         if ( s->pfile_in_zip_read != NULL ) {
1578                 unzCloseCurrentFile( file );
1579         }
1580
1581         fclose( s->file );
1582         free( s );
1583         return UNZ_OK;
1584 }
1585
1586
1587 /*
1588    Write info about the ZipFile in the *pglobal_info structure.
1589    No preparation of the structure is needed
1590    return UNZ_OK if there is no problem. */
1591 extern int unzGetGlobalInfo( unzFile file,unz_global_info *pglobal_info ){
1592         unz_s* s;
1593         if ( file == NULL ) {
1594                 return UNZ_PARAMERROR;
1595         }
1596         s = (unz_s*)file;
1597         *pglobal_info = s->gi;
1598         return UNZ_OK;
1599 }
1600
1601
1602 /*
1603    Translate date/time from Dos format to tm_unz (readable more easilty)
1604  */
1605 static void unzlocal_DosDateToTmuDate( uLong ulDosDate, tm_unz* ptm ){
1606         uLong uDate;
1607         uDate = (uLong)( ulDosDate >> 16 );
1608         ptm->tm_mday = (uInt)( uDate & 0x1f ) ;
1609         ptm->tm_mon =  (uInt)( ( ( ( uDate ) & 0x1E0 ) / 0x20 ) - 1 ) ;
1610         ptm->tm_year = (uInt)( ( ( uDate & 0x0FE00 ) / 0x0200 ) + 1980 ) ;
1611
1612         ptm->tm_hour = (uInt) ( ( ulDosDate & 0xF800 ) / 0x800 );
1613         ptm->tm_min =  (uInt) ( ( ulDosDate & 0x7E0 ) / 0x20 ) ;
1614         ptm->tm_sec =  (uInt) ( 2 * ( ulDosDate & 0x1f ) ) ;
1615 }
1616
1617 /*
1618    Get Info about the current file in the zipfile, with internal only info
1619  */
1620 static int unzlocal_GetCurrentFileInfoInternal( unzFile file,
1621                                                                                                 unz_file_info *pfile_info,
1622                                                                                                 unz_file_info_internal
1623                                                                                                 *pfile_info_internal,
1624                                                                                                 char *szFileName,
1625                                                                                                 uLong fileNameBufferSize,
1626                                                                                                 void *extraField,
1627                                                                                                 uLong extraFieldBufferSize,
1628                                                                                                 char *szComment,
1629                                                                                                 uLong commentBufferSize ){
1630         unz_s* s;
1631         unz_file_info file_info;
1632         unz_file_info_internal file_info_internal;
1633         int err = UNZ_OK;
1634         uLong uMagic;
1635         long lSeek = 0;
1636
1637         if ( file == NULL ) {
1638                 return UNZ_PARAMERROR;
1639         }
1640         s = (unz_s*)file;
1641         if ( fseek( s->file,s->pos_in_central_dir + s->byte_before_the_zipfile,SEEK_SET ) != 0 ) {
1642                 err = UNZ_ERRNO;
1643         }
1644
1645
1646         /* we check the magic */
1647         if ( err == UNZ_OK ) {
1648                 if ( unzlocal_getLong( s->file,&uMagic ) != UNZ_OK ) {
1649                         err = UNZ_ERRNO;
1650                 }
1651                 else if ( uMagic != 0x02014b50 ) {
1652                         err = UNZ_BADZIPFILE;
1653                 }
1654         }
1655
1656         if ( unzlocal_getShort( s->file,&file_info.version ) != UNZ_OK ) {
1657                 err = UNZ_ERRNO;
1658         }
1659
1660         if ( unzlocal_getShort( s->file,&file_info.version_needed ) != UNZ_OK ) {
1661                 err = UNZ_ERRNO;
1662         }
1663
1664         if ( unzlocal_getShort( s->file,&file_info.flag ) != UNZ_OK ) {
1665                 err = UNZ_ERRNO;
1666         }
1667
1668         if ( unzlocal_getShort( s->file,&file_info.compression_method ) != UNZ_OK ) {
1669                 err = UNZ_ERRNO;
1670         }
1671
1672         if ( unzlocal_getLong( s->file,&file_info.dosDate ) != UNZ_OK ) {
1673                 err = UNZ_ERRNO;
1674         }
1675
1676         unzlocal_DosDateToTmuDate( file_info.dosDate,&file_info.tmu_date );
1677
1678         if ( unzlocal_getLong( s->file,&file_info.crc ) != UNZ_OK ) {
1679                 err = UNZ_ERRNO;
1680         }
1681
1682         if ( unzlocal_getLong( s->file,&file_info.compressed_size ) != UNZ_OK ) {
1683                 err = UNZ_ERRNO;
1684         }
1685
1686         if ( unzlocal_getLong( s->file,&file_info.uncompressed_size ) != UNZ_OK ) {
1687                 err = UNZ_ERRNO;
1688         }
1689
1690         if ( unzlocal_getShort( s->file,&file_info.size_filename ) != UNZ_OK ) {
1691                 err = UNZ_ERRNO;
1692         }
1693
1694         if ( unzlocal_getShort( s->file,&file_info.size_file_extra ) != UNZ_OK ) {
1695                 err = UNZ_ERRNO;
1696         }
1697
1698         if ( unzlocal_getShort( s->file,&file_info.size_file_comment ) != UNZ_OK ) {
1699                 err = UNZ_ERRNO;
1700         }
1701
1702         if ( unzlocal_getShort( s->file,&file_info.disk_num_start ) != UNZ_OK ) {
1703                 err = UNZ_ERRNO;
1704         }
1705
1706         if ( unzlocal_getShort( s->file,&file_info.internal_fa ) != UNZ_OK ) {
1707                 err = UNZ_ERRNO;
1708         }
1709
1710         if ( unzlocal_getLong( s->file,&file_info.external_fa ) != UNZ_OK ) {
1711                 err = UNZ_ERRNO;
1712         }
1713
1714         if ( unzlocal_getLong( s->file,&file_info_internal.offset_curfile ) != UNZ_OK ) {
1715                 err = UNZ_ERRNO;
1716         }
1717
1718         lSeek += file_info.size_filename;
1719         if ( ( err == UNZ_OK ) && ( szFileName != NULL ) ) {
1720                 uLong uSizeRead ;
1721                 if ( file_info.size_filename < fileNameBufferSize ) {
1722                         *( szFileName + file_info.size_filename ) = '\0';
1723                         uSizeRead = file_info.size_filename;
1724                 }
1725                 else{
1726                         uSizeRead = fileNameBufferSize;
1727                 }
1728
1729                 if ( ( file_info.size_filename > 0 ) && ( fileNameBufferSize > 0 ) ) {
1730                         if ( fread( szFileName,(uInt)uSizeRead,1,s->file ) != 1 ) {
1731                                 err = UNZ_ERRNO;
1732                         }
1733                 }
1734                 lSeek -= uSizeRead;
1735         }
1736
1737
1738         if ( ( err == UNZ_OK ) && ( extraField != NULL ) ) {
1739                 uLong uSizeRead ;
1740                 if ( file_info.size_file_extra < extraFieldBufferSize ) {
1741                         uSizeRead = file_info.size_file_extra;
1742                 }
1743                 else{
1744                         uSizeRead = extraFieldBufferSize;
1745                 }
1746
1747                 if ( lSeek != 0 ) {
1748                         if ( fseek( s->file,lSeek,SEEK_CUR ) == 0 ) {
1749                                 lSeek = 0;
1750                         }
1751                         else{
1752                                 err = UNZ_ERRNO;
1753                         }
1754                 }
1755                 if ( ( file_info.size_file_extra > 0 ) && ( extraFieldBufferSize > 0 ) ) {
1756                         if ( fread( extraField,(uInt)uSizeRead,1,s->file ) != 1 ) {
1757                                 err = UNZ_ERRNO;
1758                         }
1759                 }
1760                 lSeek += file_info.size_file_extra - uSizeRead;
1761         }
1762         else{
1763                 lSeek += file_info.size_file_extra;
1764         }
1765
1766
1767         if ( ( err == UNZ_OK ) && ( szComment != NULL ) ) {
1768                 uLong uSizeRead ;
1769                 if ( file_info.size_file_comment < commentBufferSize ) {
1770                         *( szComment + file_info.size_file_comment ) = '\0';
1771                         uSizeRead = file_info.size_file_comment;
1772                 }
1773                 else{
1774                         uSizeRead = commentBufferSize;
1775                 }
1776
1777                 if ( lSeek != 0 ) {
1778                         if ( fseek( s->file,lSeek,SEEK_CUR ) == 0 ) {
1779                                 lSeek = 0;
1780                         }
1781                         else{
1782                                 err = UNZ_ERRNO;
1783                         }
1784                 }
1785                 if ( ( file_info.size_file_comment > 0 ) && ( commentBufferSize > 0 ) ) {
1786                         if ( fread( szComment,(uInt)uSizeRead,1,s->file ) != 1 ) {
1787                                 err = UNZ_ERRNO;
1788                         }
1789                 }
1790                 lSeek += file_info.size_file_comment - uSizeRead;
1791         }
1792         else{
1793                 lSeek += file_info.size_file_comment;
1794         }
1795
1796         if ( ( err == UNZ_OK ) && ( pfile_info != NULL ) ) {
1797                 *pfile_info = file_info;
1798         }
1799
1800         if ( ( err == UNZ_OK ) && ( pfile_info_internal != NULL ) ) {
1801                 *pfile_info_internal = file_info_internal;
1802         }
1803
1804         return err;
1805 }
1806
1807
1808
1809 /*
1810    Write info about the ZipFile in the *pglobal_info structure.
1811    No preparation of the structure is needed
1812    return UNZ_OK if there is no problem.
1813  */
1814 extern int unzGetCurrentFileInfo(  unzFile file, unz_file_info *pfile_info,
1815                                                                    char *szFileName, uLong fileNameBufferSize,
1816                                                                    void *extraField, uLong extraFieldBufferSize,
1817                                                                    char *szComment, uLong commentBufferSize ){
1818         return unzlocal_GetCurrentFileInfoInternal( file,pfile_info,NULL,
1819                                                                                                 szFileName,fileNameBufferSize,
1820                                                                                                 extraField,extraFieldBufferSize,
1821                                                                                                 szComment,commentBufferSize );
1822 }
1823
1824 /*
1825    Set the current file of the zipfile to the first file.
1826    return UNZ_OK if there is no problem
1827  */
1828 extern int unzGoToFirstFile( unzFile file ){
1829         int err = UNZ_OK;
1830         unz_s* s;
1831         if ( file == NULL ) {
1832                 return UNZ_PARAMERROR;
1833         }
1834         s = (unz_s*)file;
1835         s->pos_in_central_dir = s->offset_central_dir;
1836         s->num_file = 0;
1837         err = unzlocal_GetCurrentFileInfoInternal( file,&s->cur_file_info,
1838                                                                                            &s->cur_file_info_internal,
1839                                                                                            NULL,0,NULL,0,NULL,0 );
1840         s->current_file_ok = ( err == UNZ_OK );
1841         return err;
1842 }
1843
1844
1845 /*
1846    Set the current file of the zipfile to the next file.
1847    return UNZ_OK if there is no problem
1848    return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
1849  */
1850 extern int unzGoToNextFile( unzFile file ){
1851         unz_s* s;
1852         int err;
1853
1854         if ( file == NULL ) {
1855                 return UNZ_PARAMERROR;
1856         }
1857         s = (unz_s*)file;
1858         if ( !s->current_file_ok ) {
1859                 return UNZ_END_OF_LIST_OF_FILE;
1860         }
1861         if ( s->num_file + 1 == s->gi.number_entry ) {
1862                 return UNZ_END_OF_LIST_OF_FILE;
1863         }
1864
1865         s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
1866                                                          s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
1867         s->num_file++;
1868         err = unzlocal_GetCurrentFileInfoInternal( file,&s->cur_file_info,
1869                                                                                            &s->cur_file_info_internal,
1870                                                                                            NULL,0,NULL,0,NULL,0 );
1871         s->current_file_ok = ( err == UNZ_OK );
1872         return err;
1873 }
1874
1875
1876 /*
1877    Try locate the file szFileName in the zipfile.
1878    For the iCaseSensitivity signification, see unzipStringFileNameCompare
1879
1880    return value :
1881    UNZ_OK if the file is found. It becomes the current file.
1882    UNZ_END_OF_LIST_OF_FILE if the file is not found
1883  */
1884 extern int unzLocateFile( unzFile file, const char *szFileName, int iCaseSensitivity ){
1885         unz_s* s;
1886         int err;
1887
1888
1889         uLong num_fileSaved;
1890         uLong pos_in_central_dirSaved;
1891
1892
1893         if ( file == NULL ) {
1894                 return UNZ_PARAMERROR;
1895         }
1896
1897         if ( strlen( szFileName ) >= UNZ_MAXFILENAMEINZIP ) {
1898                 return UNZ_PARAMERROR;
1899         }
1900
1901         s = (unz_s*)file;
1902         if ( !s->current_file_ok ) {
1903                 return UNZ_END_OF_LIST_OF_FILE;
1904         }
1905
1906         num_fileSaved = s->num_file;
1907         pos_in_central_dirSaved = s->pos_in_central_dir;
1908
1909         err = unzGoToFirstFile( file );
1910
1911         while ( err == UNZ_OK )
1912         {
1913                 char szCurrentFileName[UNZ_MAXFILENAMEINZIP + 1];
1914                 unzGetCurrentFileInfo( file,NULL,
1915                                                            szCurrentFileName,sizeof( szCurrentFileName ) - 1,
1916                                                            NULL,0,NULL,0 );
1917                 if ( unzStringFileNameCompare( szCurrentFileName,
1918                                                                            szFileName,iCaseSensitivity ) == 0 ) {
1919                         return UNZ_OK;
1920                 }
1921                 err = unzGoToNextFile( file );
1922         }
1923
1924         s->num_file = num_fileSaved ;
1925         s->pos_in_central_dir = pos_in_central_dirSaved ;
1926         return err;
1927 }
1928
1929
1930 /*
1931    Read the static header of the current zipfile
1932    Check the coherency of the static header and info in the end of central
1933         directory about this file
1934    store in *piSizeVar the size of extra info in static header
1935         (filename and size of extra field data)
1936  */
1937 static int unzlocal_CheckCurrentFileCoherencyHeader( unz_s* s, uInt* piSizeVar,
1938                                                                                                          uLong *poffset_local_extrafield,
1939                                                                                                          uInt *psize_local_extrafield ){
1940         uLong uMagic,uData,uFlags;
1941         uLong size_filename;
1942         uLong size_extra_field;
1943         int err = UNZ_OK;
1944
1945         *piSizeVar = 0;
1946         *poffset_local_extrafield = 0;
1947         *psize_local_extrafield = 0;
1948
1949         if ( fseek( s->file,s->cur_file_info_internal.offset_curfile +
1950                                 s->byte_before_the_zipfile,SEEK_SET ) != 0 ) {
1951                 return UNZ_ERRNO;
1952         }
1953
1954
1955         if ( err == UNZ_OK ) {
1956                 if ( unzlocal_getLong( s->file,&uMagic ) != UNZ_OK ) {
1957                         err = UNZ_ERRNO;
1958                 }
1959                 else if ( uMagic != 0x04034b50 ) {
1960                         err = UNZ_BADZIPFILE;
1961                 }
1962         }
1963
1964         if ( unzlocal_getShort( s->file,&uData ) != UNZ_OK ) {
1965                 err = UNZ_ERRNO;
1966         }
1967 /*
1968     else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
1969         err=UNZ_BADZIPFILE;
1970  */
1971         if ( unzlocal_getShort( s->file,&uFlags ) != UNZ_OK ) {
1972                 err = UNZ_ERRNO;
1973         }
1974
1975         if ( unzlocal_getShort( s->file,&uData ) != UNZ_OK ) {
1976                 err = UNZ_ERRNO;
1977         }
1978         else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.compression_method ) ) {
1979                 err = UNZ_BADZIPFILE;
1980         }
1981
1982         if ( ( err == UNZ_OK ) && ( s->cur_file_info.compression_method != 0 ) &&
1983                  ( s->cur_file_info.compression_method != Z_DEFLATED ) ) {
1984                 err = UNZ_BADZIPFILE;
1985         }
1986
1987         if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* date/time */
1988                 err = UNZ_ERRNO;
1989         }
1990
1991         if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* crc */
1992                 err = UNZ_ERRNO;
1993         }
1994         else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.crc ) &&
1995                           ( ( uFlags & 8 ) == 0 ) ) {
1996                 err = UNZ_BADZIPFILE;
1997         }
1998
1999         if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* size compr */
2000                 err = UNZ_ERRNO;
2001         }
2002         else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.compressed_size ) &&
2003                           ( ( uFlags & 8 ) == 0 ) ) {
2004                 err = UNZ_BADZIPFILE;
2005         }
2006
2007         if ( unzlocal_getLong( s->file,&uData ) != UNZ_OK ) { /* size uncompr */
2008                 err = UNZ_ERRNO;
2009         }
2010         else if ( ( err == UNZ_OK ) && ( uData != s->cur_file_info.uncompressed_size ) &&
2011                           ( ( uFlags & 8 ) == 0 ) ) {
2012                 err = UNZ_BADZIPFILE;
2013         }
2014
2015
2016         if ( unzlocal_getShort( s->file,&size_filename ) != UNZ_OK ) {
2017                 err = UNZ_ERRNO;
2018         }
2019         else if ( ( err == UNZ_OK ) && ( size_filename != s->cur_file_info.size_filename ) ) {
2020                 err = UNZ_BADZIPFILE;
2021         }
2022
2023         *piSizeVar += (uInt)size_filename;
2024
2025         if ( unzlocal_getShort( s->file,&size_extra_field ) != UNZ_OK ) {
2026                 err = UNZ_ERRNO;
2027         }
2028         *poffset_local_extrafield = s->cur_file_info_internal.offset_curfile +
2029                                                                 SIZEZIPLOCALHEADER + size_filename;
2030         *psize_local_extrafield = (uInt)size_extra_field;
2031
2032         *piSizeVar += (uInt)size_extra_field;
2033
2034         return err;
2035 }
2036
2037 /*
2038    Open for reading data the current file in the zipfile.
2039    If there is no error and the file is opened, the return value is UNZ_OK.
2040  */
2041 extern int unzOpenCurrentFile( unzFile file ){
2042         int err = UNZ_OK;
2043         int Store;
2044         uInt iSizeVar;
2045         unz_s* s;
2046         file_in_zip_read_info_s* pfile_in_zip_read_info;
2047         uLong offset_local_extrafield;  /* offset of the static extra field */
2048         uInt size_local_extrafield;     /* size of the static extra field */
2049
2050         if ( file == NULL ) {
2051                 return UNZ_PARAMERROR;
2052         }
2053         s = (unz_s*)file;
2054         if ( !s->current_file_ok ) {
2055                 return UNZ_PARAMERROR;
2056         }
2057
2058         if ( s->pfile_in_zip_read != NULL ) {
2059                 unzCloseCurrentFile( file );
2060         }
2061
2062         if ( unzlocal_CheckCurrentFileCoherencyHeader( s,&iSizeVar,
2063                                                                                                    &offset_local_extrafield,&size_local_extrafield ) != UNZ_OK ) {
2064                 return UNZ_BADZIPFILE;
2065         }
2066
2067         pfile_in_zip_read_info = (file_in_zip_read_info_s*)
2068                                                          safe_malloc( sizeof( file_in_zip_read_info_s ) );
2069         if ( pfile_in_zip_read_info == NULL ) {
2070                 return UNZ_INTERNALERROR;
2071         }
2072
2073         pfile_in_zip_read_info->read_buffer = (char*)safe_malloc( UNZ_BUFSIZE );
2074         pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
2075         pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
2076         pfile_in_zip_read_info->pos_local_extrafield = 0;
2077
2078         if ( pfile_in_zip_read_info->read_buffer == NULL ) {
2079                 free( pfile_in_zip_read_info );
2080                 return UNZ_INTERNALERROR;
2081         }
2082
2083         pfile_in_zip_read_info->stream_initialised = 0;
2084
2085         if ( ( s->cur_file_info.compression_method != 0 ) &&
2086                  ( s->cur_file_info.compression_method != Z_DEFLATED ) ) {
2087                 err = UNZ_BADZIPFILE;
2088         }
2089         Store = s->cur_file_info.compression_method == 0;
2090
2091         pfile_in_zip_read_info->crc32_wait = s->cur_file_info.crc;
2092         pfile_in_zip_read_info->crc32 = 0;
2093         pfile_in_zip_read_info->compression_method =
2094                 s->cur_file_info.compression_method;
2095         pfile_in_zip_read_info->file = s->file;
2096         pfile_in_zip_read_info->byte_before_the_zipfile = s->byte_before_the_zipfile;
2097
2098         pfile_in_zip_read_info->stream.total_out = 0;
2099
2100         if ( !Store ) {
2101                 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
2102                 pfile_in_zip_read_info->stream.zfree = (free_func)0;
2103                 pfile_in_zip_read_info->stream.opaque = (voidp)0;
2104
2105                 err = inflateInit2( &pfile_in_zip_read_info->stream, -MAX_WBITS );
2106                 if ( err == Z_OK ) {
2107                         pfile_in_zip_read_info->stream_initialised = 1;
2108                 }
2109                 /* windowBits is passed < 0 to tell that there is no zlib header.
2110                  * Note that in this case inflate *requires* an extra "dummy" byte
2111                  * after the compressed stream in order to complete decompression and
2112                  * return Z_STREAM_END.
2113                  * In unzip, i don't wait absolutely Z_STREAM_END because I known the
2114                  * size of both compressed and uncompressed data
2115                  */
2116         }
2117         pfile_in_zip_read_info->rest_read_compressed =
2118                 s->cur_file_info.compressed_size ;
2119         pfile_in_zip_read_info->rest_read_uncompressed =
2120                 s->cur_file_info.uncompressed_size ;
2121
2122
2123         pfile_in_zip_read_info->pos_in_zipfile =
2124                 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
2125                 iSizeVar;
2126
2127         pfile_in_zip_read_info->stream.avail_in = (uInt)0;
2128
2129
2130         s->pfile_in_zip_read = pfile_in_zip_read_info;
2131         return UNZ_OK;
2132 }
2133
2134
2135 /*
2136    Read bytes from the current file.
2137    buf contain buffer where data must be copied
2138    len the size of buf.
2139
2140    return the number of byte copied if somes bytes are copied
2141    return 0 if the end of file was reached
2142    return <0 with error code if there is an error
2143     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
2144  */
2145 extern int unzReadCurrentFile( unzFile file, void *buf, unsigned len ){
2146         int err = UNZ_OK;
2147         uInt iRead = 0;
2148         unz_s* s;
2149         file_in_zip_read_info_s* pfile_in_zip_read_info;
2150         if ( file == NULL ) {
2151                 return UNZ_PARAMERROR;
2152         }
2153         s = (unz_s*)file;
2154         pfile_in_zip_read_info = s->pfile_in_zip_read;
2155
2156         if ( pfile_in_zip_read_info == NULL ) {
2157                 return UNZ_PARAMERROR;
2158         }
2159
2160
2161         if ( ( pfile_in_zip_read_info->read_buffer == NULL ) ) {
2162                 return UNZ_END_OF_LIST_OF_FILE;
2163         }
2164         if ( len == 0 ) {
2165                 return 0;
2166         }
2167
2168         pfile_in_zip_read_info->stream.next_out = (Byte*)buf;
2169
2170         pfile_in_zip_read_info->stream.avail_out = (uInt)len;
2171
2172         if ( len > pfile_in_zip_read_info->rest_read_uncompressed ) {
2173                 pfile_in_zip_read_info->stream.avail_out =
2174                         (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
2175         }
2176
2177         while ( pfile_in_zip_read_info->stream.avail_out > 0 )
2178         {
2179                 if ( ( pfile_in_zip_read_info->stream.avail_in == 0 ) &&
2180                          ( pfile_in_zip_read_info->rest_read_compressed > 0 ) ) {
2181                         uInt uReadThis = UNZ_BUFSIZE;
2182                         if ( pfile_in_zip_read_info->rest_read_compressed < uReadThis ) {
2183                                 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
2184                         }
2185                         if ( uReadThis == 0 ) {
2186                                 return UNZ_EOF;
2187                         }
2188                         if ( s->cur_file_info.compressed_size == pfile_in_zip_read_info->rest_read_compressed ) {
2189                                 if ( fseek( pfile_in_zip_read_info->file,
2190                                                         pfile_in_zip_read_info->pos_in_zipfile +
2191                                                         pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET ) != 0 ) {
2192                                         return UNZ_ERRNO;
2193                                 }
2194                         }
2195                         if ( fread( pfile_in_zip_read_info->read_buffer,uReadThis,1,
2196                                                 pfile_in_zip_read_info->file ) != 1 ) {
2197                                 return UNZ_ERRNO;
2198                         }
2199                         pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
2200
2201                         pfile_in_zip_read_info->rest_read_compressed -= uReadThis;
2202
2203                         pfile_in_zip_read_info->stream.next_in =
2204                                 (Byte*)pfile_in_zip_read_info->read_buffer;
2205                         pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
2206                 }
2207
2208                 if ( pfile_in_zip_read_info->compression_method == 0 ) {
2209                         uInt uDoCopy,i ;
2210                         if ( pfile_in_zip_read_info->stream.avail_out <
2211                                  pfile_in_zip_read_info->stream.avail_in ) {
2212                                 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
2213                         }
2214                         else{
2215                                 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
2216                         }
2217
2218                         for ( i = 0; i < uDoCopy; i++ )
2219                                 *( pfile_in_zip_read_info->stream.next_out + i ) =
2220                                         *( pfile_in_zip_read_info->stream.next_in + i );
2221
2222                         pfile_in_zip_read_info->crc32 = crc32( pfile_in_zip_read_info->crc32,
2223                                                                                                    pfile_in_zip_read_info->stream.next_out,
2224                                                                                                    uDoCopy );
2225                         pfile_in_zip_read_info->rest_read_uncompressed -= uDoCopy;
2226                         pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
2227                         pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
2228                         pfile_in_zip_read_info->stream.next_out += uDoCopy;
2229                         pfile_in_zip_read_info->stream.next_in += uDoCopy;
2230                         pfile_in_zip_read_info->stream.total_out += uDoCopy;
2231                         iRead += uDoCopy;
2232                 }
2233                 else
2234                 {
2235                         uLong uTotalOutBefore,uTotalOutAfter;
2236                         const Byte *bufBefore;
2237                         uLong uOutThis;
2238                         int flush = Z_SYNC_FLUSH;
2239
2240                         uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
2241                         bufBefore = pfile_in_zip_read_info->stream.next_out;
2242
2243                         /*
2244                            if ((pfile_in_zip_read_info->rest_read_uncompressed ==
2245                                  pfile_in_zip_read_info->stream.avail_out) &&
2246                             (pfile_in_zip_read_info->rest_read_compressed == 0))
2247                             flush = Z_FINISH;
2248                          */
2249                         err = inflate( &pfile_in_zip_read_info->stream,flush );
2250
2251                         uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
2252                         uOutThis = uTotalOutAfter - uTotalOutBefore;
2253
2254                         pfile_in_zip_read_info->crc32 =
2255                                 crc32( pfile_in_zip_read_info->crc32,bufBefore,
2256                                            (uInt)( uOutThis ) );
2257
2258                         pfile_in_zip_read_info->rest_read_uncompressed -=
2259                                 uOutThis;
2260
2261                         iRead += (uInt)( uTotalOutAfter - uTotalOutBefore );
2262
2263                         if ( err == Z_STREAM_END ) {
2264                                 return ( iRead == 0 ) ? UNZ_EOF : iRead;
2265                         }
2266                         if ( err != Z_OK ) {
2267                                 break;
2268                         }
2269                 }
2270         }
2271
2272         if ( err == Z_OK ) {
2273                 return iRead;
2274         }
2275         return err;
2276 }
2277
2278
2279 /*
2280    Give the current position in uncompressed data
2281  */
2282 extern long unztell( unzFile file ){
2283         unz_s* s;
2284         file_in_zip_read_info_s* pfile_in_zip_read_info;
2285         if ( file == NULL ) {
2286                 return UNZ_PARAMERROR;
2287         }
2288         s = (unz_s*)file;
2289         pfile_in_zip_read_info = s->pfile_in_zip_read;
2290
2291         if ( pfile_in_zip_read_info == NULL ) {
2292                 return UNZ_PARAMERROR;
2293         }
2294
2295         return (long)pfile_in_zip_read_info->stream.total_out;
2296 }
2297
2298
2299 /*
2300    return 1 if the end of file was reached, 0 elsewhere
2301  */
2302 extern int unzeof( unzFile file ){
2303         unz_s* s;
2304         file_in_zip_read_info_s* pfile_in_zip_read_info;
2305         if ( file == NULL ) {
2306                 return UNZ_PARAMERROR;
2307         }
2308         s = (unz_s*)file;
2309         pfile_in_zip_read_info = s->pfile_in_zip_read;
2310
2311         if ( pfile_in_zip_read_info == NULL ) {
2312                 return UNZ_PARAMERROR;
2313         }
2314
2315         if ( pfile_in_zip_read_info->rest_read_uncompressed == 0 ) {
2316                 return 1;
2317         }
2318         else{
2319                 return 0;
2320         }
2321 }
2322
2323
2324
2325 /*
2326    Read extra field from the current file (opened by unzOpenCurrentFile)
2327    This is the static-header version of the extra field (sometimes, there is
2328     more info in the static-header version than in the central-header)
2329
2330    if buf==NULL, it return the size of the static extra field that can be read
2331
2332    if buf!=NULL, len is the size of the buffer, the extra header is copied in
2333     buf.
2334    the return value is the number of bytes copied in buf, or (if <0)
2335     the error code
2336  */
2337 extern int unzGetLocalExtrafield( unzFile file,void *buf,unsigned len ){
2338         unz_s* s;
2339         file_in_zip_read_info_s* pfile_in_zip_read_info;
2340         uInt read_now;
2341         uLong size_to_read;
2342
2343         if ( file == NULL ) {
2344                 return UNZ_PARAMERROR;
2345         }
2346         s = (unz_s*)file;
2347         pfile_in_zip_read_info = s->pfile_in_zip_read;
2348
2349         if ( pfile_in_zip_read_info == NULL ) {
2350                 return UNZ_PARAMERROR;
2351         }
2352
2353         size_to_read = ( pfile_in_zip_read_info->size_local_extrafield -
2354                                          pfile_in_zip_read_info->pos_local_extrafield );
2355
2356         if ( buf == NULL ) {
2357                 return (int)size_to_read;
2358         }
2359
2360         if ( len > size_to_read ) {
2361                 read_now = (uInt)size_to_read;
2362         }
2363         else{
2364                 read_now = (uInt)len ;
2365         }
2366
2367         if ( read_now == 0 ) {
2368                 return 0;
2369         }
2370
2371         if ( fseek( pfile_in_zip_read_info->file,
2372                                 pfile_in_zip_read_info->offset_local_extrafield +
2373                                 pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET ) != 0 ) {
2374                 return UNZ_ERRNO;
2375         }
2376
2377         if ( fread( buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file ) != 1 ) {
2378                 return UNZ_ERRNO;
2379         }
2380
2381         return (int)read_now;
2382 }
2383
2384 /*
2385    Close the file in zip opened with unzipOpenCurrentFile
2386    Return UNZ_CRCERROR if all the file was read but the CRC is not good
2387  */
2388 extern int unzCloseCurrentFile( unzFile file ){
2389         int err = UNZ_OK;
2390
2391         unz_s* s;
2392         file_in_zip_read_info_s* pfile_in_zip_read_info;
2393         if ( file == NULL ) {
2394                 return UNZ_PARAMERROR;
2395         }
2396         s = (unz_s*)file;
2397         pfile_in_zip_read_info = s->pfile_in_zip_read;
2398
2399         if ( pfile_in_zip_read_info == NULL ) {
2400                 return UNZ_PARAMERROR;
2401         }
2402
2403
2404         if ( pfile_in_zip_read_info->rest_read_uncompressed == 0 ) {
2405                 if ( pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait ) {
2406                         err = UNZ_CRCERROR;
2407                 }
2408         }
2409
2410
2411         free( pfile_in_zip_read_info->read_buffer );
2412         pfile_in_zip_read_info->read_buffer = NULL;
2413         if ( pfile_in_zip_read_info->stream_initialised ) {
2414                 inflateEnd( &pfile_in_zip_read_info->stream );
2415         }
2416
2417         pfile_in_zip_read_info->stream_initialised = 0;
2418         free( pfile_in_zip_read_info );
2419
2420         s->pfile_in_zip_read = NULL;
2421
2422         return err;
2423 }
2424
2425
2426 /*
2427    Get the global comment string of the ZipFile, in the szComment buffer.
2428    uSizeBuf is the size of the szComment buffer.
2429    return the number of byte copied or an error code <0
2430  */
2431 extern int unzGetGlobalComment( unzFile file, char *szComment, uLong uSizeBuf ){
2432         unz_s* s;
2433         uLong uReadThis ;
2434         if ( file == NULL ) {
2435                 return UNZ_PARAMERROR;
2436         }
2437         s = (unz_s*)file;
2438
2439         uReadThis = uSizeBuf;
2440         if ( uReadThis > s->gi.size_comment ) {
2441                 uReadThis = s->gi.size_comment;
2442         }
2443
2444         if ( fseek( s->file,s->central_pos + 22,SEEK_SET ) != 0 ) {
2445                 return UNZ_ERRNO;
2446         }
2447
2448         if ( uReadThis > 0 ) {
2449                 *szComment = '\0';
2450                 if ( fread( szComment,(uInt)uReadThis,1,s->file ) != 1 ) {
2451                         return UNZ_ERRNO;
2452                 }
2453         }
2454
2455         if ( ( szComment != NULL ) && ( uSizeBuf > s->gi.size_comment ) ) {
2456                 *( szComment + s->gi.size_comment ) = '\0';
2457         }
2458         return (int)uReadThis;
2459 }
2460
2461 /* crc32.c -- compute the CRC-32 of a data stream
2462  * Copyright (C) 1995-1998 Mark Adler
2463  * For conditions of distribution and use, see copyright notice in zlib.h
2464  */
2465
2466
2467 #ifdef DYNAMIC_CRC_TABLE
2468
2469 static int crc_table_empty = 1;
2470 static uLong crc_table[256];
2471 static void make_crc_table OF( (void) );
2472
2473 /*
2474    Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
2475    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.
2476
2477    Polynomials over GF(2) are represented in binary, one bit per coefficient,
2478    with the lowest powers in the most significant bit.  Then adding polynomials
2479    is just exclusive-or, and multiplying a polynomial by x is a right shift by
2480    one.  If we call the above polynomial p, and represent a byte as the
2481    polynomial q, also with the lowest power in the most significant bit (so the
2482    byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
2483    where a mod b means the remainder after dividing a by b.
2484
2485    This calculation is done using the shift-register method of multiplying and
2486    taking the remainder.  The register is initialized to zero, and for each
2487    incoming bit, x^32 is added mod p to the register if the bit is a one (where
2488    x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
2489    x (which is shifting right by one and adding x^32 mod p if the bit shifted
2490    out is a one).  We start with the highest power (least significant bit) of
2491    q and repeat for all eight bits of q.
2492
2493    The table is simply the CRC of all possible eight bit values.  This is all
2494    the information needed to generate CRC's on data a byte at a time for all
2495    combinations of CRC register values and incoming bytes.
2496  */
2497 static void make_crc_table(){
2498         uLong c;
2499         int n, k;
2500         uLong poly;          /* polynomial exclusive-or pattern */
2501         /* terms of polynomial defining this crc (except x^32): */
2502         static const Byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
2503
2504         /* make exclusive-or pattern from polynomial (0xedb88320L) */
2505         poly = 0L;
2506         for ( n = 0; n < sizeof( p ) / sizeof( Byte ); n++ )
2507                 poly |= 1L << ( 31 - p[n] );
2508
2509         for ( n = 0; n < 256; n++ )
2510         {
2511                 c = (uLong)n;
2512                 for ( k = 0; k < 8; k++ )
2513                         c = c & 1 ? poly ^ ( c >> 1 ) : c >> 1;
2514                 crc_table[n] = c;
2515         }
2516         crc_table_empty = 0;
2517 }
2518 #else
2519 /* ========================================================================
2520  * Table of CRC-32's of all single-byte values (made by make_crc_table)
2521  */
2522 static const uLong crc_table[256] = {
2523         0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
2524         0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
2525         0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
2526         0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
2527         0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
2528         0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
2529         0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
2530         0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
2531         0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
2532         0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
2533         0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
2534         0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
2535         0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
2536         0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
2537         0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
2538         0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
2539         0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
2540         0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
2541         0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
2542         0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
2543         0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
2544         0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
2545         0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
2546         0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
2547         0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
2548         0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
2549         0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
2550         0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
2551         0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
2552         0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
2553         0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
2554         0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
2555         0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
2556         0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
2557         0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
2558         0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
2559         0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
2560         0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
2561         0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
2562         0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
2563         0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
2564         0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
2565         0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
2566         0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
2567         0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
2568         0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
2569         0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
2570         0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
2571         0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
2572         0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
2573         0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
2574         0x2d02ef8dL
2575 };
2576 #endif
2577
2578 /* =========================================================================
2579  * This function can be used by asm versions of crc32()
2580  */
2581 #ifndef __APPLE__
2582 const uLong * get_crc_table(){
2583 #ifdef DYNAMIC_CRC_TABLE
2584         if ( crc_table_empty ) {
2585                 make_crc_table();
2586         }
2587 #endif
2588         return (const uLong *)crc_table;
2589 }
2590 #endif
2591
2592 /* ========================================================================= */
2593 #define DO1( buf ) crc = crc_table[( (int)crc ^ ( *buf++ ) ) & 0xff] ^ ( crc >> 8 );
2594 #define DO2( buf )  DO1( buf ); DO1( buf );
2595 #define DO4( buf )  DO2( buf ); DO2( buf );
2596 #define DO8( buf )  DO4( buf ); DO4( buf );
2597
2598 /* ========================================================================= */
2599 #ifndef __APPLE__
2600 uLong crc32( uLong crc, const Byte *buf, uInt len ){
2601         if ( buf == Z_NULL ) {
2602                 return 0L;
2603         }
2604 #ifdef DYNAMIC_CRC_TABLE
2605         if ( crc_table_empty ) {
2606                 make_crc_table();
2607         }
2608 #endif
2609         crc = crc ^ 0xffffffffL;
2610         while ( len >= 8 )
2611         {
2612                 DO8( buf );
2613                 len -= 8;
2614         }
2615         if ( len ) {
2616                 do {
2617                         DO1( buf );
2618                 } while ( --len );
2619         }
2620         return crc ^ 0xffffffffL;
2621 }
2622 #endif
2623
2624 /* infblock.h -- header to use infblock.c
2625  * Copyright (C) 1995-1998 Mark Adler
2626  * For conditions of distribution and use, see copyright notice in zlib.h
2627  */
2628
2629 /* WARNING: this file should *not* be used by applications. It is
2630    part of the implementation of the compression library and is
2631    subject to change. Applications should only use zlib.h.
2632  */
2633
2634 struct inflate_blocks_state;
2635 typedef struct inflate_blocks_state inflate_blocks_statef;
2636
2637 extern inflate_blocks_statef * inflate_blocks_new OF( (
2638                                                                                                                   z_streamp z,
2639                                                                                                                   check_func c, /* check function */
2640                                                                                                                   uInt w ) ); /* window size */
2641
2642 extern int inflate_blocks OF( (
2643                                                                   inflate_blocks_statef *,
2644                                                                   z_streamp,
2645                                                                   int ) ); /* initial return code */
2646
2647 extern void inflate_blocks_reset OF( (
2648                                                                                  inflate_blocks_statef *,
2649                                                                                  z_streamp,
2650                                                                                  uLong * ) ); /* check value on output */
2651
2652 extern int inflate_blocks_free OF( (
2653                                                                            inflate_blocks_statef *,
2654                                                                            z_streamp ) );
2655
2656 extern void inflate_set_dictionary OF( (
2657                                                                                    inflate_blocks_statef * s,
2658                                                                                    const Byte * d, /* dictionary */
2659                                                                                    uInt n ) ); /* dictionary length */
2660
2661 extern int inflate_blocks_sync_point OF( (
2662                                                                                          inflate_blocks_statef * s ) );
2663
2664 /* simplify the use of the inflate_huft type with some defines */
2665 #define exop word.what.Exop
2666 #define bits word.what.Bits
2667
2668 /* Table for deflate from PKZIP's appnote.txt. */
2669 static const uInt border[] = { /* Order of the bit length code lengths */
2670         16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
2671 };
2672
2673 /* inftrees.h -- header to use inftrees.c
2674  * Copyright (C) 1995-1998 Mark Adler
2675  * For conditions of distribution and use, see copyright notice in zlib.h
2676  */
2677
2678 /* WARNING: this file should *not* be used by applications. It is
2679    part of the implementation of the compression library and is
2680    subject to change. Applications should only use zlib.h.
2681  */
2682
2683 /* Huffman code lookup table entry--this entry is four bytes for machines
2684    that have 16-bit pointers (e.g. PC's in the small or medium model). */
2685
2686 typedef struct inflate_huft_s inflate_huft;
2687
2688 struct inflate_huft_s {
2689         union {
2690                 struct {
2691                         Byte Exop;  /* number of extra bits or operation */
2692                         Byte Bits;  /* number of bits in this code or subcode */
2693                 } what;
2694                 uInt pad;       /* pad structure to a power of 2 (4 bytes for */
2695         } word;             /*  16-bit, 8 bytes for 32-bit int's) */
2696         uInt base;          /* literal, length base, distance base,
2697                                or table offset */
2698 };
2699
2700 /* Maximum size of dynamic tree.  The maximum found in a long but non-
2701    exhaustive search was 1004 huft structures (850 for length/literals
2702    and 154 for distances, the latter actually the result of an
2703    exhaustive search).  The actual maximum is not known, but the
2704    value below is more than safe. */
2705 #define MANY 1440
2706
2707 extern int inflate_trees_bits OF( (
2708                                                                           uInt *, /* 19 code lengths */
2709                                                                           uInt *, /* bits tree desired/actual depth */
2710                                                                           inflate_huft * *, /* bits tree result */
2711                                                                           inflate_huft *, /* space for trees */
2712                                                                           z_streamp ) ); /* for messages */
2713
2714 extern int inflate_trees_dynamic OF( (
2715                                                                                  uInt, /* number of literal/length codes */
2716                                                                                  uInt, /* number of distance codes */
2717                                                                                  uInt *, /* that many (total) code lengths */
2718                                                                                  uInt *, /* literal desired/actual bit depth */
2719                                                                                  uInt *, /* distance desired/actual bit depth */
2720                                                                                  inflate_huft * *, /* literal/length tree result */
2721                                                                                  inflate_huft * *, /* distance tree result */
2722                                                                                  inflate_huft *, /* space for trees */
2723                                                                                  z_streamp ) ); /* for messages */
2724
2725 extern int inflate_trees_fixed OF( (
2726                                                                            uInt *, /* literal desired/actual bit depth */
2727                                                                            uInt *, /* distance desired/actual bit depth */
2728                                                                            inflate_huft * *, /* literal/length tree result */
2729                                                                            inflate_huft * *, /* distance tree result */
2730                                                                            z_streamp ) ); /* for memory allocation */
2731
2732
2733 /* infcodes.h -- header to use infcodes.c
2734  * Copyright (C) 1995-1998 Mark Adler
2735  * For conditions of distribution and use, see copyright notice in zlib.h
2736  */
2737
2738 /* WARNING: this file should *not* be used by applications. It is
2739    part of the implementation of the compression library and is
2740    subject to change. Applications should only use zlib.h.
2741  */
2742
2743 struct inflate_codes_state;
2744 typedef struct inflate_codes_state inflate_codes_statef;
2745
2746 extern inflate_codes_statef *inflate_codes_new OF( (
2747                                                                                                            uInt, uInt,
2748                                                                                                            inflate_huft *, inflate_huft *,
2749                                                                                                            z_streamp ) );
2750
2751 extern int inflate_codes OF( (
2752                                                                  inflate_blocks_statef *,
2753                                                                  z_streamp,
2754                                                                  int ) );
2755
2756 extern void inflate_codes_free OF( (
2757                                                                            inflate_codes_statef *,
2758                                                                            z_streamp ) );
2759
2760 /* infutil.h -- types and macros common to blocks and codes
2761  * Copyright (C) 1995-1998 Mark Adler
2762  * For conditions of distribution and use, see copyright notice in zlib.h
2763  */
2764
2765 /* WARNING: this file should *not* be used by applications. It is
2766    part of the implementation of the compression library and is
2767    subject to change. Applications should only use zlib.h.
2768  */
2769
2770 #ifndef _INFUTIL_H
2771 #define _INFUTIL_H
2772
2773 typedef enum {
2774         TYPE,       /* get type bits (3, including end bit) */
2775         LENS,       /* get lengths for stored */
2776         STORED,     /* processing stored block */
2777         TABLE,      /* get table lengths */
2778         BTREE,      /* get bit lengths tree for a dynamic block */
2779         DTREE,      /* get length, distance trees for a dynamic block */
2780         CODES,      /* processing fixed or dynamic block */
2781         DRY,        /* output remaining window bytes */
2782         DONE,       /* finished last block, done */
2783         BAD
2784 }               /* got a data error--stuck here */
2785 inflate_block_mode;
2786
2787 /* inflate blocks semi-private state */
2788 struct inflate_blocks_state {
2789
2790         /* mode */
2791         inflate_block_mode mode;    /* current inflate_block mode */
2792
2793         /* mode dependent information */
2794         union {
2795                 uInt left;      /* if STORED, bytes left to copy */
2796                 struct {
2797                         uInt table;         /* table lengths (14 bits) */
2798                         uInt index;         /* index into blens (or border) */
2799                         uInt *blens;       /* bit lengths of codes */
2800                         uInt bb;            /* bit length tree depth */
2801                         inflate_huft *tb;   /* bit length decoding tree */
2802                 } trees;        /* if DTREE, decoding info for trees */
2803                 struct {
2804                         inflate_codes_statef
2805                         *codes;
2806                 } decode;       /* if CODES, current state */
2807         } sub;              /* submode */
2808         uInt last;          /* true if this block is the last block */
2809
2810         /* mode independent information */
2811         uInt bitk;          /* bits in bit buffer */
2812         uLong bitb;         /* bit buffer */
2813         inflate_huft *hufts; /* single safe_malloc for tree space */
2814         Byte *window;      /* sliding window */
2815         Byte *end;         /* one byte after sliding window */
2816         Byte *read;        /* window read pointer */
2817         Byte *write;       /* window write pointer */
2818         check_func checkfn; /* check function */
2819         uLong check;        /* check on output */
2820
2821 };
2822
2823
2824 /* defines for inflate input/output */
2825 /*   update pointers and return */
2826 #define UPDBITS {s->bitb = b; s->bitk = k; }
2827 #define UPDIN {z->avail_in = n; z->total_in += p - z->next_in; z->next_in = p; }
2828 #define UPDOUT {s->write = q; }
2829 #define UPDATE {UPDBITS UPDIN UPDOUT}
2830 #define LEAVE {UPDATE return inflate_flush( s,z,r ); }
2831 /*   get bytes and bits */
2832 #define LOADIN {p = z->next_in; n = z->avail_in; b = s->bitb; k = s->bitk; }
2833 #define NEEDBYTE {if ( n ) {r = Z_OK; }else LEAVE}
2834 #define NEXTBYTE ( n--,*p++ )
2835 #define NEEDBITS( j ) {while ( k < ( j ) ) {NEEDBYTE; b |= ( (uLong)NEXTBYTE ) << k; k += 8; }}
2836 #define DUMPBITS( j ) {b >>= ( j ); k -= ( j ); }
2837 /*   output bytes */
2838 #define WAVAIL (uInt)( q < s->read ? s->read - q - 1 : s->end - q )
2839 #define LOADOUT {q = s->write; m = (uInt)WAVAIL; }
2840 #define WRAP {if ( q == s->end && s->read != s->window ) {q = s->window; m = (uInt)WAVAIL; }}
2841 #define FLUSH {UPDOUT r = inflate_flush( s,z,r ); LOADOUT}
2842 #define NEEDOUT {if ( m == 0 ) {WRAP if ( m == 0 ) {FLUSH WRAP if ( m == 0 ) {LEAVE}} r = Z_OK; }}
2843 #define OUTBYTE( a ) {*q++ = (Byte)( a ); m--; }
2844 /*   load static pointers */
2845 #define LOAD {LOADIN LOADOUT}
2846
2847 /* masks for lower bits (size given to avoid silly warnings with Visual C++) */
2848 extern uInt inflate_mask[17];
2849
2850 /* copy as much as possible from the sliding window to the output area */
2851 extern int inflate_flush OF( (
2852                                                                  inflate_blocks_statef *,
2853                                                                  z_streamp,
2854                                                                  int ) );
2855
2856 #endif
2857
2858
2859 /*
2860    Notes beyond the 1.93a appnote.txt:
2861
2862    1. Distance pointers never point before the beginning of the output
2863       stream.
2864    2. Distance pointers can point back across blocks, up to 32k away.
2865    3. There is an implied maximum of 7 bits for the bit length table and
2866       15 bits for the actual data.
2867    4. If only one code exists, then it is encoded using one bit.  (Zero
2868       would be more efficient, but perhaps a little confusing.)  If two
2869       codes exist, they are coded using one bit each (0 and 1).
2870    5. There is no way of sending zero distance codes--a dummy must be
2871       sent if there are none.  (History: a pre 2.0 version of PKZIP would
2872       store blocks with no distance codes, but this was discovered to be
2873       too harsh a criterion.)  Valid only for 1.93a.  2.04c does allow
2874       zero distance codes, which is sent as one code of zero bits in
2875       length.
2876    6. There are up to 286 literal/length codes.  Code 256 represents the
2877       end-of-block.  Note however that the static length tree defines
2878       288 codes just to fill out the Huffman codes.  Codes 286 and 287
2879       cannot be used though, since there is no length base or extra bits
2880       defined for them.  Similarily, there are up to 30 distance codes.
2881       However, static trees define 32 codes (all 5 bits) to fill out the
2882       Huffman codes, but the last two had better not show up in the data.
2883    7. Unzip can check dynamic Huffman blocks for complete code sets.
2884       The exception is that a single code would not be complete (see #4).
2885    8. The five bits following the block type is really the number of
2886       literal codes sent minus 257.
2887    9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
2888       (1+6+6).  Therefore, to output three times the length, you output
2889       three codes (1+1+1), whereas to output four times the same length,
2890       you only need two codes (1+3).  Hmm.
2891    10. In the tree reconstruction algorithm, Code = Code + Increment
2892       only if BitLength(i) is not zero.  (Pretty obvious.)
2893    11. Correction: 4 Bits: # of Bit Length codes - 4     (4 - 19)
2894    12. Note: length code 284 can represent 227-258, but length code 285
2895       really is 258.  The last length deserves its own, short code
2896       since it gets used a lot in very redundant files.  The length
2897       258 is special since 258 - 3 (the min match length) is 255.
2898    13. The literal/length and distance code bit lengths are read as a
2899       single stream of lengths.  It is possible (and advantageous) for
2900       a repeat code (16, 17, or 18) to go across the boundary between
2901       the two sets of lengths.
2902  */
2903
2904
2905 #ifndef __APPLE__
2906 void inflate_blocks_reset( inflate_blocks_statef *s, z_streamp z, uLong *c ){
2907         if ( c != Z_NULL ) {
2908                 *c = s->check;
2909         }
2910         if ( s->mode == BTREE || s->mode == DTREE ) {
2911                 ZFREE( z, s->sub.trees.blens );
2912         }
2913         if ( s->mode == CODES ) {
2914                 inflate_codes_free( s->sub.decode.codes, z );
2915         }
2916         s->mode = TYPE;
2917         s->bitk = 0;
2918         s->bitb = 0;
2919         s->read = s->write = s->window;
2920         if ( s->checkfn != Z_NULL ) {
2921                 z->adler = s->check = ( *s->checkfn )( 0L, (const Byte *)Z_NULL, 0 );
2922         }
2923         Tracev( ( "inflate:   blocks reset\n" ) );
2924 }
2925 #endif
2926
2927 #ifndef __APPLE__
2928 inflate_blocks_statef *inflate_blocks_new( z_streamp z, check_func c, uInt w ){
2929         inflate_blocks_statef *s;
2930
2931         if ( ( s = (inflate_blocks_statef *)ZALLOC
2932                                    ( z,1,sizeof( struct inflate_blocks_state ) ) ) == Z_NULL ) {
2933                 return s;
2934         }
2935         if ( ( s->hufts =
2936                            (inflate_huft *)ZALLOC( z, sizeof( inflate_huft ), MANY ) ) == Z_NULL ) {
2937                 ZFREE( z, s );
2938                 return Z_NULL;
2939         }
2940         if ( ( s->window = (Byte *)ZALLOC( z, 1, w ) ) == Z_NULL ) {
2941                 ZFREE( z, s->hufts );
2942                 ZFREE( z, s );
2943                 return Z_NULL;
2944         }
2945         s->end = s->window + w;
2946         s->checkfn = c;
2947         s->mode = TYPE;
2948         Tracev( ( "inflate:   blocks allocated\n" ) );
2949         inflate_blocks_reset( s, z, Z_NULL );
2950         return s;
2951 }
2952 #endif
2953
2954 #ifndef __APPLE__
2955 int inflate_blocks( inflate_blocks_statef *s, z_streamp z, int r ){
2956         uInt t;             /* temporary storage */
2957         uLong b;            /* bit buffer */
2958         uInt k;             /* bits in bit buffer */
2959         Byte *p;           /* input data pointer */
2960         uInt n;             /* bytes available there */
2961         Byte *q;           /* output window write pointer */
2962         uInt m;             /* bytes to end of window or read pointer */
2963
2964         /* copy input/output information to locals (UPDATE macro restores) */
2965         LOAD
2966
2967         /* process input based on current state */
2968         while ( 1 ) switch ( s->mode )
2969                 {
2970                 case TYPE:
2971                         NEEDBITS( 3 )
2972                         t = (uInt)b & 7;
2973                         s->last = t & 1;
2974                         switch ( t >> 1 )
2975                         {
2976                         case 0:                     /* stored */
2977                                 Tracev( ( "inflate:     stored block%s\n",
2978                                                   s->last ? " (last)" : "" ) );
2979                                 DUMPBITS( 3 )
2980                                 t = k & 7;              /* go to byte boundary */
2981                                 DUMPBITS( t )
2982                                 s->mode = LENS;         /* get length of stored block */
2983                                 break;
2984                         case 1:                     /* fixed */
2985                                 Tracev( ( "inflate:     fixed codes block%s\n",
2986                                                   s->last ? " (last)" : "" ) );
2987                                 {
2988                                         uInt bl, bd;
2989                                         inflate_huft *tl, *td;
2990
2991                                         inflate_trees_fixed( &bl, &bd, &tl, &td, z );
2992                                         s->sub.decode.codes = inflate_codes_new( bl, bd, tl, td, z );
2993                                         if ( s->sub.decode.codes == Z_NULL ) {
2994                                                 r = Z_MEM_ERROR;
2995                                                 LEAVE
2996                                         }
2997                                 }
2998                                 DUMPBITS( 3 )
2999                                 s->mode = CODES;
3000                                 break;
3001                         case 2:                     /* dynamic */
3002                                 Tracev( ( "inflate:     dynamic codes block%s\n",
3003                                                   s->last ? " (last)" : "" ) );
3004                                 DUMPBITS( 3 )
3005                                 s->mode = TABLE;
3006                                 break;
3007                         case 3:                     /* illegal */
3008                                 DUMPBITS( 3 )
3009                                 s->mode = BAD;
3010                                 z->msg = (char*)"invalid block type";
3011                                 r = Z_DATA_ERROR;
3012                                 LEAVE
3013                         }
3014                         break;
3015                 case LENS:
3016                         NEEDBITS( 32 )
3017                         if ( ( ( ( ~b ) >> 16 ) & 0xffff ) != ( b & 0xffff ) ) {
3018                                 s->mode = BAD;
3019                                 z->msg = (char*)"invalid stored block lengths";
3020                                 r = Z_DATA_ERROR;
3021                                 LEAVE
3022                         }
3023                         s->sub.left = (uInt)b & 0xffff;
3024                         b = k = 0;                /* dump bits */
3025                         Tracev( ( "inflate:       stored length %u\n", s->sub.left ) );
3026                         s->mode = s->sub.left ? STORED : ( s->last ? DRY : TYPE );
3027                         break;
3028                 case STORED:
3029                         if ( n == 0 ) {
3030                                 LEAVE
3031                                 NEEDOUT
3032                                         t = s->sub.left;
3033                         }
3034                         if ( t > n ) {
3035                                 t = n;
3036                         }
3037                         if ( t > m ) {
3038                                 t = m;
3039                         }
3040                         zmemcpy( q, p, t );
3041                         p += t;  n -= t;
3042                         q += t;  m -= t;
3043                         if ( ( s->sub.left -= t ) != 0 ) {
3044                                 break;
3045                         }
3046                         Tracev( ( "inflate:       stored end, %lu total out\n",
3047                                           z->total_out + ( q >= s->read ? q - s->read :
3048                                                                            ( s->end - s->read ) + ( q - s->window ) ) ) );
3049                         s->mode = s->last ? DRY : TYPE;
3050                         break;
3051                 case TABLE:
3052                         NEEDBITS( 14 )
3053                         s->sub.trees.table = t = (uInt)b & 0x3fff;
3054 #ifndef PKZIP_BUG_WORKAROUND
3055                         if ( ( t & 0x1f ) > 29 || ( ( t >> 5 ) & 0x1f ) > 29 ) {
3056                                 s->mode = BAD;
3057                                 z->msg = (char*)"too many length or distance symbols";
3058                                 r = Z_DATA_ERROR;
3059                                 LEAVE
3060                         }
3061 #endif
3062                         t = 258 + ( t & 0x1f ) + ( ( t >> 5 ) & 0x1f );
3063                         if ( ( s->sub.trees.blens = (uInt*)ZALLOC( z, t, sizeof( uInt ) ) ) == Z_NULL ) {
3064                                 r = Z_MEM_ERROR;
3065                                 LEAVE
3066                         }
3067                         DUMPBITS( 14 )
3068                         s->sub.trees.index = 0;
3069                         Tracev( ( "inflate:       table sizes ok\n" ) );
3070                         s->mode = BTREE;
3071                 case BTREE:
3072                         while ( s->sub.trees.index < 4 + ( s->sub.trees.table >> 10 ) )
3073                         {
3074                                 NEEDBITS( 3 )
3075                                 s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
3076                                 DUMPBITS( 3 )
3077                         }
3078                         while ( s->sub.trees.index < 19 )
3079                                 s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
3080                         s->sub.trees.bb = 7;
3081                         t = inflate_trees_bits( s->sub.trees.blens, &s->sub.trees.bb,
3082                                                                         &s->sub.trees.tb, s->hufts, z );
3083                         if ( t != Z_OK ) {
3084                                 ZFREE( z, s->sub.trees.blens );
3085                                 r = t;
3086                                 if ( r == Z_DATA_ERROR ) {
3087                                         s->mode = BAD;
3088                                 }
3089                                 LEAVE
3090                         }
3091                         s->sub.trees.index = 0;
3092                         Tracev( ( "inflate:       bits tree ok\n" ) );
3093                         s->mode = DTREE;
3094                 case DTREE:
3095                         while ( t = s->sub.trees.table,
3096                                         s->sub.trees.index < 258 + ( t & 0x1f ) + ( ( t >> 5 ) & 0x1f ) )
3097                         {
3098                                 inflate_huft *h;
3099                                 uInt i, j, c;
3100
3101                                 t = s->sub.trees.bb;
3102                                 NEEDBITS( t )
3103                                 h = s->sub.trees.tb + ( (uInt)b & inflate_mask[t] );
3104                                 t = h->bits;
3105                                 c = h->base;
3106                                 if ( c < 16 ) {
3107                                         DUMPBITS( t )
3108                                         s->sub.trees.blens[s->sub.trees.index++] = c;
3109                                 }
3110                                 else /* c == 16..18 */
3111                                 {
3112                                         i = c == 18 ? 7 : c - 14;
3113                                         j = c == 18 ? 11 : 3;
3114                                         NEEDBITS( t + i )
3115                                         DUMPBITS( t )
3116                                         j += (uInt)b & inflate_mask[i];
3117                                         DUMPBITS( i )
3118                                         i = s->sub.trees.index;
3119                                         t = s->sub.trees.table;
3120                                         if ( i + j > 258 + ( t & 0x1f ) + ( ( t >> 5 ) & 0x1f ) ||
3121                                                  ( c == 16 && i < 1 ) ) {
3122                                                 ZFREE( z, s->sub.trees.blens );
3123                                                 s->mode = BAD;
3124                                                 z->msg = (char*)"invalid bit length repeat";
3125                                                 r = Z_DATA_ERROR;
3126                                                 LEAVE
3127                                         }
3128                                         c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
3129                                         do {
3130                                                 s->sub.trees.blens[i++] = c;
3131                                         } while ( --j );
3132                                         s->sub.trees.index = i;
3133                                 }
3134                         }
3135                         s->sub.trees.tb = Z_NULL;
3136                         {
3137                                 uInt bl, bd;
3138                                 inflate_huft *tl, *td;
3139                                 inflate_codes_statef *c;
3140
3141                                 bl = 9; /* must be <= 9 for lookahead assumptions */
3142                                 bd = 6; /* must be <= 9 for lookahead assumptions */
3143                                 t = s->sub.trees.table;
3144                                 t = inflate_trees_dynamic( 257 + ( t & 0x1f ), 1 + ( ( t >> 5 ) & 0x1f ),
3145                                                                                    s->sub.trees.blens, &bl, &bd, &tl, &td,
3146                                                                                    s->hufts, z );
3147                                 ZFREE( z, s->sub.trees.blens );
3148                                 if ( t != Z_OK ) {
3149                                         if ( t == (uInt)Z_DATA_ERROR ) {
3150                                                 s->mode = BAD;
3151                                         }
3152                                         r = t;
3153                                         LEAVE
3154                                 }
3155                                 Tracev( ( "inflate:       trees ok\n" ) );
3156                                 if ( ( c = inflate_codes_new( bl, bd, tl, td, z ) ) == Z_NULL ) {
3157                                         r = Z_MEM_ERROR;
3158                                         LEAVE
3159                                 }
3160                                 s->sub.decode.codes = c;
3161                         }
3162                         s->mode = CODES;
3163                 case CODES:
3164                         UPDATE
3165                         if ( ( r = inflate_codes( s, z, r ) ) != Z_STREAM_END ) {
3166                                 return inflate_flush( s, z, r );
3167                         }
3168                         r = Z_OK;
3169                         inflate_codes_free( s->sub.decode.codes, z );
3170                         LOAD
3171                         Tracev( ( "inflate:       codes end, %lu total out\n",
3172                                           z->total_out + ( q >= s->read ? q - s->read :
3173                                                                            ( s->end - s->read ) + ( q - s->window ) ) ) );
3174                         if ( !s->last ) {
3175                                 s->mode = TYPE;
3176                                 break;
3177                         }
3178                         s->mode = DRY;
3179                 case DRY:
3180                         FLUSH
3181                         if ( s->read != s->write ) {
3182                                 LEAVE
3183                                 s->mode = DONE;
3184                         }
3185                 case DONE:
3186                         r = Z_STREAM_END;
3187                         LEAVE
3188                 case BAD:
3189                         r = Z_DATA_ERROR;
3190                         LEAVE
3191                 default:
3192                         r = Z_STREAM_ERROR;
3193                         LEAVE
3194                 }
3195 }
3196 #endif
3197
3198 #ifndef __APPLE__
3199 int inflate_blocks_free( inflate_blocks_statef *s, z_streamp z ){
3200         inflate_blocks_reset( s, z, Z_NULL );
3201         ZFREE( z, s->window );
3202         ZFREE( z, s->hufts );
3203         ZFREE( z, s );
3204         Tracev( ( "inflate:   blocks freed\n" ) );
3205         return Z_OK;
3206 }
3207 #endif
3208
3209 #ifndef __APPLE__
3210 void inflate_set_dictionary( inflate_blocks_statef *s, const Byte *d, uInt n ){
3211         zmemcpy( s->window, d, n );
3212         s->read = s->write = s->window + n;
3213 }
3214 #endif
3215
3216 /* Returns true if inflate is currently at the end of a block generated
3217  * by Z_SYNC_FLUSH or Z_FULL_FLUSH.
3218  * IN assertion: s != Z_NULL
3219  */
3220 #ifndef __APPLE__
3221 int inflate_blocks_sync_point( inflate_blocks_statef *s ){
3222         return s->mode == LENS;
3223 }
3224 #endif
3225
3226 /* And'ing with mask[n] masks the lower n bits */
3227 uInt inflate_mask[17] = {
3228         0x0000,
3229         0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
3230         0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
3231 };
3232
3233 /* copy as much as possible from the sliding window to the output area */
3234 #ifndef __APPLE__
3235 int inflate_flush( inflate_blocks_statef *s, z_streamp z, int r ){
3236         uInt n;
3237         Byte *p;
3238         Byte *q;
3239
3240         /* static copies of source and destination pointers */
3241         p = z->next_out;
3242         q = s->read;
3243
3244         /* compute number of bytes to copy as as end of window */
3245         n = (uInt)( ( q <= s->write ? s->write : s->end ) - q );
3246         if ( n > z->avail_out ) {
3247                 n = z->avail_out;
3248         }
3249         if ( n && r == Z_BUF_ERROR ) {
3250                 r = Z_OK;
3251         }
3252
3253         /* update counters */
3254         z->avail_out -= n;
3255         z->total_out += n;
3256
3257         /* update check information */
3258         if ( s->checkfn != Z_NULL ) {
3259                 z->adler = s->check = ( *s->checkfn )( s->check, q, n );
3260         }
3261
3262         /* copy as as end of window */
3263         zmemcpy( p, q, n );
3264         p += n;
3265         q += n;
3266
3267         /* see if more to copy at beginning of window */
3268         if ( q == s->end ) {
3269                 /* wrap pointers */
3270                 q = s->window;
3271                 if ( s->write == s->end ) {
3272                         s->write = s->window;
3273                 }
3274
3275                 /* compute bytes to copy */
3276                 n = (uInt)( s->write - q );
3277                 if ( n > z->avail_out ) {
3278                         n = z->avail_out;
3279                 }
3280                 if ( n && r == Z_BUF_ERROR ) {
3281                         r = Z_OK;
3282                 }
3283
3284                 /* update counters */
3285                 z->avail_out -= n;
3286                 z->total_out += n;
3287
3288                 /* update check information */
3289                 if ( s->checkfn != Z_NULL ) {
3290                         z->adler = s->check = ( *s->checkfn )( s->check, q, n );
3291                 }
3292
3293                 /* copy */
3294                 zmemcpy( p, q, n );
3295                 p += n;
3296                 q += n;
3297         }
3298
3299         /* update pointers */
3300         z->next_out = p;
3301         s->read = q;
3302
3303         /* done */
3304         return r;
3305 }
3306 #endif
3307
3308 /* inftrees.c -- generate Huffman trees for efficient decoding
3309  * Copyright (C) 1995-1998 Mark Adler
3310  * For conditions of distribution and use, see copyright notice in zlib.h
3311  */
3312
3313 #ifndef __APPLE__
3314 const char inflate_copyright[] =
3315         " inflate 1.1.3 Copyright 1995-1998 Mark Adler ";
3316 #endif
3317
3318 /*
3319    If you use the zlib library in a product, an acknowledgment is welcome
3320    in the documentation of your product. If for some reason you cannot
3321    include such an acknowledgment, I would appreciate that you keep this
3322    copyright string in the executable of your product.
3323  */
3324
3325 /* simplify the use of the inflate_huft type with some defines */
3326 #define exop word.what.Exop
3327 #define bits word.what.Bits
3328
3329
3330 static int huft_build OF( (
3331                                                           uInt *, /* code lengths in bits */
3332                                                           uInt, /* number of codes */
3333                                                           uInt, /* number of "simple" codes */
3334                                                           const uInt *, /* list of base values for non-simple codes */
3335                                                           const uInt *, /* list of extra bits for non-simple codes */
3336                                                           inflate_huft * *, /* result: starting table */
3337                                                           uInt *, /* maximum lookup bits (returns actual) */
3338                                                           inflate_huft *, /* space for trees */
3339                                                           uInt *, /* hufts used in space */
3340                                                           uInt * ) ); /* space for values */
3341
3342 /* Tables for deflate from PKZIP's appnote.txt. */
3343 static const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
3344         3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
3345         35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
3346 };
3347 /* see note #13 above about 258 */
3348 static const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
3349         0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
3350         3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112
3351 };                                                        /* 112==invalid */
3352 static const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
3353         1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
3354         257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
3355         8193, 12289, 16385, 24577
3356 };
3357 static const uInt cpdext[30] = { /* Extra bits for distance codes */
3358         0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
3359         7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
3360         12, 12, 13, 13
3361 };
3362
3363 /*
3364    Huffman code decoding is performed using a multi-level table lookup.
3365    The fastest way to decode is to simply build a lookup table whose
3366    size is determined by the longest code.  However, the time it takes
3367    to build this table can also be a factor if the data being decoded
3368    is not very long.  The most common codes are necessarily the
3369    shortest codes, so those codes dominate the decoding time, and hence
3370    the speed.  The idea is you can have a shorter table that decodes the
3371    shorter, more probable codes, and then point to subsidiary tables for
3372    the longer codes.  The time it costs to decode the longer codes is
3373    then traded against the time it takes to make longer tables.
3374
3375    This results of this trade are in the variables lbits and dbits
3376    below.  lbits is the number of bits the first level table for literal/
3377    length codes can decode in one step, and dbits is the same thing for
3378    the distance codes.  Subsequent tables are also less than or equal to
3379    those sizes.  These values may be adjusted either when all of the
3380    codes are shorter than that, in which case the longest code length in
3381    bits is used, or when the shortest code is *longer* than the requested
3382    table size, in which case the length of the shortest code in bits is
3383    used.
3384
3385    There are two different values for the two tables, since they code a
3386    different number of possibilities each.  The literal/length table
3387    codes 286 possible values, or in a flat code, a little over eight
3388    bits.  The distance table codes 30 possible values, or a little less
3389    than five bits, flat.  The optimum values for speed end up being
3390    about one bit more than those, so lbits is 8+1 and dbits is 5+1.
3391    The optimum values may differ though from machine to machine, and
3392    possibly even between compilers.  Your mileage may vary.
3393  */
3394
3395
3396 /* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
3397 #define BMAX 15         /* maximum bit length of any code */
3398
3399 static int huft_build( uInt *b, uInt n, uInt s, const uInt *d, const uInt *e, inflate_huft ** t, uInt *m, inflate_huft *hp, uInt *hn, uInt *v ){
3400 //uInt *b;               /* code lengths in bits (all assumed <= BMAX) */
3401 //uInt n;                 /* number of codes (assumed <= 288) */
3402 //uInt s;                 /* number of simple-valued codes (0..s-1) */
3403 //const uInt *d;         /* list of base values for non-simple codes */
3404 //const uInt *e;         /* list of extra bits for non-simple codes */
3405 //inflate_huft ** t;            /* result: starting table */
3406 //uInt *m;               /* maximum lookup bits, returns actual */
3407 //inflate_huft *hp;       /* space for trees */
3408 //uInt *hn;               /* hufts used in space */
3409 //uInt *v;               /* working area: values in order of bit length */
3410 /* Given a list of code lengths and a maximum table size, make a set of
3411    tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
3412    if the given code set is incomplete (the tables are still built in this
3413    case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
3414    lengths), or Z_MEM_ERROR if not enough memory. */
3415
3416         uInt a;                     /* counter for codes of length k */
3417         uInt c[BMAX + 1];           /* bit length count table */
3418         uInt f;                     /* i repeats in table every f entries */
3419         int g;                      /* maximum code length */
3420         int h;                      /* table level */
3421         register uInt i;            /* counter, current code */
3422         register uInt j;            /* counter */
3423         register int k;             /* number of bits in current code */
3424         int l;                      /* bits per table (returned in m) */
3425         uInt mask;                  /* (1 << w) - 1, to avoid cc -O bug on HP */
3426         register uInt *p;          /* pointer into c[], b[], or v[] */
3427         inflate_huft *q;            /* points to current table */
3428         struct inflate_huft_s r;    /* table entry for structure assignment */
3429         inflate_huft *u[BMAX];      /* table stack */
3430         register int w;             /* bits before this table == (l * h) */
3431         uInt x[BMAX + 1];           /* bit offsets, then code stack */
3432         uInt *xp;                  /* pointer into x */
3433         int y;                      /* number of dummy codes added */
3434         uInt z;                     /* number of entries in current table */
3435
3436
3437         /* Generate counts for each bit length */
3438         p = c;
3439 #define C0 *p++ = 0;
3440 #define C2 C0 C0 C0 C0
3441 #define C4 C2 C2 C2 C2
3442         C4                          /* clear c[]--assume BMAX+1 is 16 */
3443                 p = b;  i = n;
3444         do {
3445                 c[*p++]++;              /* assume all entries <= BMAX */
3446         } while ( --i );
3447         if ( c[0] == n ) {          /* null input--all zero length codes */
3448                 *t = (inflate_huft *)Z_NULL;
3449                 *m = 0;
3450                 return Z_OK;
3451         }
3452
3453
3454         /* Find minimum and maximum length, bound *m by those */
3455         l = *m;
3456         for ( j = 1; j <= BMAX; j++ )
3457                 if ( c[j] ) {
3458                         break;
3459                 }
3460         k = j;                      /* minimum code length */
3461         if ( (uInt)l < j ) {
3462                 l = j;
3463         }
3464         for ( i = BMAX; i; i-- )
3465                 if ( c[i] ) {
3466                         break;
3467                 }
3468         g = i;                      /* maximum code length */
3469         if ( (uInt)l > i ) {
3470                 l = i;
3471         }
3472         *m = l;
3473
3474
3475         /* Adjust last length count to fill out codes, if needed */
3476         for ( y = 1 << j; j < i; j++, y <<= 1 )
3477                 if ( ( y -= c[j] ) < 0 ) {
3478                         return Z_DATA_ERROR;
3479                 }
3480         if ( ( y -= c[i] ) < 0 ) {
3481                 return Z_DATA_ERROR;
3482         }
3483         c[i] += y;
3484
3485
3486         /* Generate starting offsets into the value table for each length */
3487         x[1] = j = 0;
3488         p = c + 1;  xp = x + 2;
3489         while ( --i ) {             /* note that i == g from above */
3490                 *xp++ = ( j += *p++ );
3491         }
3492
3493
3494         /* Make a table of values in order of bit lengths */
3495         p = b;  i = 0;
3496         do {
3497                 if ( ( j = *p++ ) != 0 ) {
3498                         v[x[j]++] = i;
3499                 }
3500         } while ( ++i < n );
3501         n = x[g];                   /* set n to length of v */
3502
3503
3504         /* Generate the Huffman codes and for each, make the table entries */
3505         x[0] = i = 0;               /* first Huffman code is zero */
3506         p = v;                      /* grab values in bit order */
3507         h = -1;                     /* no tables yet--level -1 */
3508         w = -l;                     /* bits decoded == (l * h) */
3509         u[0] = (inflate_huft *)Z_NULL;      /* just to keep compilers happy */
3510         q = (inflate_huft *)Z_NULL; /* ditto */
3511         z = 0;                      /* ditto */
3512
3513         /* go through the bit lengths (k already is bits in shortest code) */
3514         for (; k <= g; k++ )
3515         {
3516                 a = c[k];
3517                 while ( a-- )
3518                 {
3519                         /* here i is the Huffman code of length k bits for value *p */
3520                         /* make tables up to required level */
3521                         while ( k > w + l )
3522                         {
3523                                 h++;
3524                                 w += l;         /* previous table always l bits */
3525
3526                                 /* compute minimum size table less than or equal to l bits */
3527                                 z = g - w;
3528                                 z = z > (uInt)l ? l : z; /* table size upper limit */
3529                                 if ( ( f = 1 << ( j = k - w ) ) > a + 1 ) { /* try a k-w bit table */
3530                                         /* too few codes for k-w bit table */
3531                                         f -= a + 1; /* deduct codes from patterns left */
3532                                         xp = c + k;
3533                                         if ( j < z ) {
3534                                                 while ( ++j < z ) /* try smaller tables up to z bits */
3535                                                 {
3536                                                         if ( ( f <<= 1 ) <= *++xp ) {
3537                                                                 break; /* enough codes to use up j bits */
3538                                                         }
3539                                                         f -= *xp; /* else deduct codes from patterns */
3540                                                 }
3541                                         }
3542                                 }
3543                                 z = 1 << j;     /* table entries for j-bit table */
3544
3545                                 /* allocate new table */
3546                                 if ( *hn + z > MANY ) { /* (note: doesn't matter for fixed) */
3547                                         return Z_MEM_ERROR; /* not enough memory */
3548                                 }
3549                                 u[h] = q = hp + *hn;
3550                                 *hn += z;
3551
3552                                 /* connect to last table, if there is one */
3553                                 if ( h ) {
3554                                         x[h] = i;   /* save pattern for backing up */
3555                                         r.bits = (Byte)l; /* bits to dump before this table */
3556                                         r.exop = (Byte)j; /* bits in this table */
3557                                         j = i >> ( w - l );
3558                                         r.base = (uInt)( q - u[h - 1] - j ); /* offset to this table */
3559                                         u[h - 1][j] = r; /* connect to last table */
3560                                 }
3561                                 else{</