AllocWinding: fix handling of compiler enforced alignment of double
[divverent/netradiant.git] / tools / quake3 / common / unzip.c
1 /*
2 Copyright (C) 1999-2006 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 {
970         byte    b1,b2;
971
972         b1 = l&255;
973         b2 = (l>>8)&255;
974
975         return (b1<<8) + b2;
976 }
977
978 short   __BigShort (short l)
979 {
980         return l;
981 }
982
983
984 int    __LittleLong (int l)
985 {
986         byte    b1,b2,b3,b4;
987
988         b1 = l&255;
989         b2 = (l>>8)&255;
990         b3 = (l>>16)&255;
991         b4 = (l>>24)&255;
992
993         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
994 }
995
996 int    __BigLong (int l)
997 {
998         return l;
999 }
1000
1001
1002 float   __LittleFloat (float l)
1003 {
1004         union {byte b[4]; float f;} in, out;
1005         
1006         in.f = l;
1007         out.b[0] = in.b[3];
1008         out.b[1] = in.b[2];
1009         out.b[2] = in.b[1];
1010         out.b[3] = in.b[0];
1011         
1012         return out.f;
1013 }
1014
1015 float   __BigFloat (float l)
1016 {
1017         return l;
1018 }
1019
1020
1021 #else
1022
1023
1024 short   __BigShort (short l)
1025 {
1026         byte    b1,b2;
1027
1028         b1 = l&255;
1029         b2 = (l>>8)&255;
1030
1031         return (b1<<8) + b2;
1032 }
1033
1034 short   __LittleShort (short l)
1035 {
1036         return l;
1037 }
1038
1039
1040 int    __BigLong (int l)
1041 {
1042         byte    b1,b2,b3,b4;
1043
1044         b1 = l&255;
1045         b2 = (l>>8)&255;
1046         b3 = (l>>16)&255;
1047         b4 = (l>>24)&255;
1048
1049         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
1050 }
1051
1052 int    __LittleLong (int l)
1053 {
1054         return l;
1055 }
1056
1057 float   __BigFloat (float l)
1058 {
1059         union {byte b[4]; float f;} in, out;
1060         
1061         in.f = l;
1062         out.b[0] = in.b[3];
1063         out.b[1] = in.b[2];
1064         out.b[2] = in.b[1];
1065         out.b[3] = in.b[0];
1066         
1067         return out.f;
1068 }
1069
1070 float   __LittleFloat (float l)
1071 {
1072         return l;
1073 }
1074
1075
1076
1077 #endif
1078
1079
1080
1081
1082                         /* various hacks, don't look :) */
1083
1084 /* deflateInit and inflateInit are macros to allow checking the zlib version
1085  * and the compiler's view of z_stream:
1086  */
1087 int deflateInit_ OF((z_streamp strm, int level,
1088                                      const char *version, int stream_size));
1089 int inflateInit_ OF((z_streamp strm,
1090                                      const char *version, int stream_size));
1091 int deflateInit2_ OF((z_streamp strm, int  level, int  method,
1092                                       int windowBits, int memLevel,
1093                                       int strategy, const char *version,
1094                                       int stream_size));
1095 int inflateInit2_ OF((z_streamp strm, int  windowBits,
1096                                       const char *version, int stream_size));
1097 #define deflateInit(strm, level) \
1098         deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
1099 #define inflateInit(strm) \
1100         inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
1101 #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
1102         deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
1103                       (strategy),           ZLIB_VERSION, sizeof(z_stream))
1104 #define inflateInit2(strm, windowBits) \
1105         inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
1106
1107
1108 const char   * zError           OF((int err));
1109 int            inflateSyncPoint OF((z_streamp z));
1110 const uLong * get_crc_table    OF((void));
1111
1112 typedef unsigned char  uch;
1113 typedef unsigned short ush;
1114 typedef unsigned long  ulg;
1115
1116 extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
1117 /* (size given to avoid silly warnings with Visual C++) */
1118
1119 #define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
1120
1121 #define ERR_RETURN(strm,err) \
1122   return (strm->msg = (char*)ERR_MSG(err), (err))
1123 /* To be used only when the state is known to be valid */
1124
1125         /* common constants */
1126
1127 #ifndef DEF_WBITS
1128 #  define DEF_WBITS MAX_WBITS
1129 #endif
1130 /* default windowBits for decompression. MAX_WBITS is for compression only */
1131
1132 #if MAX_MEM_LEVEL >= 8
1133 #  define DEF_MEM_LEVEL 8
1134 #else
1135 #  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
1136 #endif
1137 /* default memLevel */
1138
1139 #define STORED_BLOCK 0
1140 #define STATIC_TREES 1
1141 #define DYN_TREES    2
1142 /* The three kinds of block type */
1143
1144 #define MIN_MATCH  3
1145 #define MAX_MATCH  258
1146 /* The minimum and maximum match lengths */
1147
1148 #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
1149
1150         /* target dependencies */
1151
1152         /* Common defaults */
1153
1154 #ifndef OS_CODE
1155 #  define OS_CODE  0x03  /* assume Unix */
1156 #endif
1157
1158 #ifndef F_OPEN
1159 #  define F_OPEN(name, mode) fopen((name), (mode))
1160 #endif
1161
1162          /* functions */
1163
1164 #ifdef HAVE_STRERROR
1165    extern char *strerror OF((int));
1166 #  define zstrerror(errnum) strerror(errnum)
1167 #else
1168 #  define zstrerror(errnum) ""
1169 #endif
1170
1171 #define zmemcpy memcpy
1172 #define zmemcmp memcmp
1173 #define zmemzero(dest, len) memset(dest, 0, len)
1174
1175 /* Diagnostic functions */
1176 #ifdef _ZIP_DEBUG_
1177    int z_verbose = 0;
1178 #  define Assert(cond,msg) assert(cond);
1179    //{if(!(cond)) Sys_Error(msg);}
1180 #  define Trace(x) {if (z_verbose>=0) Sys_Error x ;}
1181 #  define Tracev(x) {if (z_verbose>0) Sys_Error x ;}
1182 #  define Tracevv(x) {if (z_verbose>1) Sys_Error x ;}
1183 #  define Tracec(c,x) {if (z_verbose>0 && (c)) Sys_Error x ;}
1184 #  define Tracecv(c,x) {if (z_verbose>1 && (c)) Sys_Error x ;}
1185 #else
1186 #  define Assert(cond,msg)
1187 #  define Trace(x)
1188 #  define Tracev(x)
1189 #  define Tracevv(x)
1190 #  define Tracec(c,x)
1191 #  define Tracecv(c,x)
1192 #endif
1193
1194
1195 typedef uLong (*check_func) OF((uLong check, const Byte *buf, uInt len));
1196 voidp zcalloc OF((voidp opaque, unsigned items, unsigned size));
1197 void   zcfree  OF((voidp opaque, voidp ptr));
1198
1199 #define ZALLOC(strm, items, size) \
1200            (*((strm)->zalloc))((strm)->opaque, (items), (size))
1201 #define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidp)(addr))
1202 #define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
1203
1204
1205 #if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
1206                       !defined(CASESENSITIVITYDEFAULT_NO)
1207 #define CASESENSITIVITYDEFAULT_NO
1208 #endif
1209
1210
1211 #ifndef UNZ_BUFSIZE
1212 #define UNZ_BUFSIZE (65536)
1213 #endif
1214
1215 #ifndef UNZ_MAXFILENAMEINZIP
1216 #define UNZ_MAXFILENAMEINZIP (256)
1217 #endif
1218
1219 #ifndef ALLOC
1220 # define ALLOC(size) (safe_malloc(size))
1221 #endif
1222 #ifndef TRYFREE
1223 # define TRYFREE(p) {if (p) free(p);}
1224 #endif
1225
1226 #define SIZECENTRALDIRITEM (0x2e)
1227 #define SIZEZIPLOCALHEADER (0x1e)
1228
1229
1230
1231 /* ===========================================================================
1232      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
1233    for end of file.
1234    IN assertion: the stream s has been sucessfully opened for reading.
1235 */
1236
1237 /*
1238 static int unzlocal_getByte(FILE *fin,int *pi)
1239 {
1240     unsigned char c;
1241         int err = fread(&c, 1, 1, fin);
1242     if (err==1)
1243     {
1244         *pi = (int)c;
1245         return UNZ_OK;
1246     }
1247     else
1248     {
1249         if (ferror(fin)) 
1250             return UNZ_ERRNO;
1251         else
1252             return UNZ_EOF;
1253     }
1254 }
1255 */
1256
1257 /* ===========================================================================
1258    Reads a long in LSB order from the given gz_stream. Sets 
1259 */
1260 static int unzlocal_getShort (FILE* fin, uLong *pX)
1261 {
1262         short   v;
1263
1264         if(fread( &v, sizeof(v), 1, fin ) != 1)
1265                 return UNZ_EOF;
1266
1267         *pX = __LittleShort( v);
1268         return UNZ_OK;
1269
1270 /*
1271     uLong x ;
1272     int i;
1273     int err;
1274
1275     err = unzlocal_getByte(fin,&i);
1276     x = (uLong)i;
1277     
1278     if (err==UNZ_OK)
1279         err = unzlocal_getByte(fin,&i);
1280     x += ((uLong)i)<<8;
1281    
1282     if (err==UNZ_OK)
1283         *pX = x;
1284     else
1285         *pX = 0;
1286     return err;
1287 */
1288 }
1289
1290 static int unzlocal_getLong (FILE *fin, uLong *pX)
1291 {
1292         int             v;
1293
1294         if(fread( &v, sizeof(v), 1, fin ) != 1)
1295                 return UNZ_EOF;
1296
1297         *pX = __LittleLong( v);
1298         return UNZ_OK;
1299
1300 /*
1301     uLong x ;
1302     int i;
1303     int err;
1304
1305     err = unzlocal_getByte(fin,&i);
1306     x = (uLong)i;
1307     
1308     if (err==UNZ_OK)
1309         err = unzlocal_getByte(fin,&i);
1310     x += ((uLong)i)<<8;
1311
1312     if (err==UNZ_OK)
1313         err = unzlocal_getByte(fin,&i);
1314     x += ((uLong)i)<<16;
1315
1316     if (err==UNZ_OK)
1317         err = unzlocal_getByte(fin,&i);
1318     x += ((uLong)i)<<24;
1319    
1320     if (err==UNZ_OK)
1321         *pX = x;
1322     else
1323         *pX = 0;
1324     return err;
1325 */
1326 }
1327
1328
1329 /* My own strcmpi / strcasecmp */
1330 static int strcmpcasenosensitive_internal (const char* fileName1,const char* fileName2)
1331 {
1332         for (;;)
1333         {
1334                 char c1=*(fileName1++);
1335                 char c2=*(fileName2++);
1336                 if ((c1>='a') && (c1<='z'))
1337                         c1 -= 0x20;
1338                 if ((c2>='a') && (c2<='z'))
1339                         c2 -= 0x20;
1340                 if (c1=='\0')
1341                         return ((c2=='\0') ? 0 : -1);
1342                 if (c2=='\0')
1343                         return 1;
1344                 if (c1<c2)
1345                         return -1;
1346                 if (c1>c2)
1347                         return 1;
1348         }
1349 }
1350
1351
1352 #ifdef  CASESENSITIVITYDEFAULT_NO
1353 #define CASESENSITIVITYDEFAULTVALUE 2
1354 #else
1355 #define CASESENSITIVITYDEFAULTVALUE 1
1356 #endif
1357
1358 #ifndef STRCMPCASENOSENTIVEFUNCTION
1359 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
1360 #endif
1361
1362 /* 
1363    Compare two filename (fileName1,fileName2).
1364    If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
1365    If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
1366                                                                 or strcasecmp)
1367    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
1368         (like 1 on Unix, 2 on Windows)
1369
1370 */
1371 extern int unzStringFileNameCompare (const char* fileName1,const char* fileName2,int iCaseSensitivity)
1372 {
1373         if (iCaseSensitivity==0)
1374                 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
1375
1376         if (iCaseSensitivity==1)
1377                 return strcmp(fileName1,fileName2);
1378
1379         return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
1380
1381
1382 #define BUFREADCOMMENT (0x400)
1383
1384 /*
1385   Locate the Central directory of a zipfile (at the end, just before
1386     the global comment)
1387 */
1388 static uLong unzlocal_SearchCentralDir(FILE *fin)
1389 {
1390         unsigned char* buf;
1391         uLong uSizeFile;
1392         uLong uBackRead;
1393         uLong uMaxBack=0xffff; /* maximum size of global comment */
1394         uLong uPosFound=0;
1395         
1396         if (fseek(fin,0,SEEK_END) != 0)
1397                 return 0;
1398
1399
1400         uSizeFile = ftell( fin );
1401         
1402         if (uMaxBack>uSizeFile)
1403                 uMaxBack = uSizeFile;
1404
1405         buf = (unsigned char*)safe_malloc(BUFREADCOMMENT+4);
1406         if (buf==NULL)
1407                 return 0;
1408
1409         uBackRead = 4;
1410         while (uBackRead<uMaxBack)
1411         {
1412                 uLong uReadSize,uReadPos ;
1413                 int i;
1414                 if (uBackRead+BUFREADCOMMENT>uMaxBack) 
1415                         uBackRead = uMaxBack;
1416                 else
1417                         uBackRead+=BUFREADCOMMENT;
1418                 uReadPos = uSizeFile-uBackRead ;
1419                 
1420                 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? 
1421                      (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
1422                 if (fseek(fin,uReadPos,SEEK_SET)!=0)
1423                         break;
1424
1425                 if (fread(buf,(uInt)uReadSize,1,fin)!=1)
1426                         break;
1427
1428                 for (i=(int)uReadSize-3; (i--)>0;)
1429                         if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && 
1430                                 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
1431                         {
1432                                 uPosFound = uReadPos+i;
1433                                 break;
1434                         }
1435
1436                 if (uPosFound!=0)
1437                         break;
1438         }
1439         free(buf);
1440         return uPosFound;
1441 }
1442
1443 extern unzFile unzReOpen (const char* path, unzFile file)
1444 {
1445         unz_s *s;
1446         FILE * fin;
1447
1448     fin=fopen(path,"rb");
1449         if (fin==NULL)
1450                 return NULL;
1451
1452         s=(unz_s*)safe_malloc(sizeof(unz_s));
1453         memcpy(s, (unz_s*)file, sizeof(unz_s));
1454
1455         s->file = fin;
1456         return (unzFile)s;      
1457 }
1458
1459 /*
1460   Open a Zip file. path contain the full pathname (by example,
1461      on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
1462          "zlib/zlib109.zip".
1463          If the zipfile cannot be opened (file don't exist or in not valid), the
1464            return value is NULL.
1465      Else, the return value is a unzFile Handle, usable with other function
1466            of this unzip package.
1467 */
1468 extern unzFile unzOpen (const char* path)
1469 {
1470         unz_s us;
1471         unz_s *s;
1472         uLong central_pos,uL;
1473         FILE * fin ;
1474
1475         uLong number_disk;          /* number of the current dist, used for 
1476                                                                    spaning ZIP, unsupported, always 0*/
1477         uLong number_disk_with_CD;  /* number the the disk with central dir, used
1478                                                                    for spaning ZIP, unsupported, always 0*/
1479         uLong number_entry_CD;      /* total number of entries in
1480                                        the central dir 
1481                                        (same than number_entry on nospan) */
1482
1483         int err=UNZ_OK;
1484
1485     fin=fopen(path,"rb");
1486         if (fin==NULL)
1487                 return NULL;
1488
1489         central_pos = unzlocal_SearchCentralDir(fin);
1490         if (central_pos==0)
1491                 err=UNZ_ERRNO;
1492
1493         if (fseek(fin,central_pos,SEEK_SET)!=0)
1494                 err=UNZ_ERRNO;
1495
1496         /* the signature, already checked */
1497         if (unzlocal_getLong(fin,&uL)!=UNZ_OK)
1498                 err=UNZ_ERRNO;
1499
1500         /* number of this disk */
1501         if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK)
1502                 err=UNZ_ERRNO;
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         /* total number of entries in the central dir on this disk */
1509         if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK)
1510                 err=UNZ_ERRNO;
1511
1512         /* total number of entries in the central dir */
1513         if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK)
1514                 err=UNZ_ERRNO;
1515
1516         if ((number_entry_CD!=us.gi.number_entry) ||
1517                 (number_disk_with_CD!=0) ||
1518                 (number_disk!=0))
1519                 err=UNZ_BADZIPFILE;
1520
1521         /* size of the central directory */
1522         if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK)
1523                 err=UNZ_ERRNO;
1524
1525         /* offset of start of central directory with respect to the 
1526               starting disk number */
1527         if (unzlocal_getLong(fin,&us.offset_central_dir)!=UNZ_OK)
1528                 err=UNZ_ERRNO;
1529
1530         /* zipfile comment length */
1531         if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK)
1532                 err=UNZ_ERRNO;
1533
1534         if ((central_pos<us.offset_central_dir+us.size_central_dir) && 
1535                 (err==UNZ_OK))
1536                 err=UNZ_BADZIPFILE;
1537
1538         if (err!=UNZ_OK)
1539         {
1540                 fclose(fin);
1541                 return NULL;
1542         }
1543
1544         us.file=fin;
1545         us.byte_before_the_zipfile = central_pos -
1546                                     (us.offset_central_dir+us.size_central_dir);
1547         us.central_pos = central_pos;
1548     us.pfile_in_zip_read = NULL;
1549         
1550
1551         s=(unz_s*)safe_malloc(sizeof(unz_s));
1552         *s=us;
1553 //      unzGoToFirstFile((unzFile)s);   
1554         return (unzFile)s;      
1555 }
1556
1557
1558 /*
1559   Close a ZipFile opened with unzipOpen.
1560   If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
1561     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
1562   return UNZ_OK if there is no problem. */
1563 extern int unzClose (unzFile file)
1564 {
1565         unz_s* s;
1566         if (file==NULL)
1567                 return UNZ_PARAMERROR;
1568         s=(unz_s*)file;
1569
1570     if (s->pfile_in_zip_read!=NULL)
1571         unzCloseCurrentFile(file);
1572
1573         fclose(s->file);
1574         free(s);
1575         return UNZ_OK;
1576 }
1577
1578
1579 /*
1580   Write info about the ZipFile in the *pglobal_info structure.
1581   No preparation of the structure is needed
1582   return UNZ_OK if there is no problem. */
1583 extern int unzGetGlobalInfo (unzFile file,unz_global_info *pglobal_info)
1584 {
1585         unz_s* s;
1586         if (file==NULL)
1587                 return UNZ_PARAMERROR;
1588         s=(unz_s*)file;
1589         *pglobal_info=s->gi;
1590         return UNZ_OK;
1591 }
1592
1593
1594 /*
1595    Translate date/time from Dos format to tm_unz (readable more easilty)
1596 */
1597 static void unzlocal_DosDateToTmuDate (uLong ulDosDate, tm_unz* ptm)
1598 {
1599     uLong uDate;
1600     uDate = (uLong)(ulDosDate>>16);
1601     ptm->tm_mday = (uInt)(uDate&0x1f) ;
1602     ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
1603     ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
1604
1605     ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
1606     ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
1607     ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
1608 }
1609
1610 /*
1611   Get Info about the current file in the zipfile, with internal only info
1612 */
1613 static int unzlocal_GetCurrentFileInfoInternal (unzFile file,
1614                                                   unz_file_info *pfile_info,
1615                                                   unz_file_info_internal 
1616                                                   *pfile_info_internal,
1617                                                   char *szFileName,
1618                                                                                                   uLong fileNameBufferSize,
1619                                                   void *extraField,
1620                                                                                                   uLong extraFieldBufferSize,
1621                                                   char *szComment,
1622                                                                                                   uLong commentBufferSize)
1623 {
1624         unz_s* s;
1625         unz_file_info file_info;
1626         unz_file_info_internal file_info_internal;
1627         int err=UNZ_OK;
1628         uLong uMagic;
1629         long lSeek=0;
1630
1631         if (file==NULL)
1632                 return UNZ_PARAMERROR;
1633         s=(unz_s*)file;
1634         if (fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0)
1635                 err=UNZ_ERRNO;
1636
1637
1638         /* we check the magic */
1639         if (err==UNZ_OK)
1640         {
1641                 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
1642                         err=UNZ_ERRNO;
1643                 else if (uMagic!=0x02014b50)
1644                         err=UNZ_BADZIPFILE;
1645         }
1646
1647         if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK)
1648                 err=UNZ_ERRNO;
1649
1650         if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK)
1651                 err=UNZ_ERRNO;
1652
1653         if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK)
1654                 err=UNZ_ERRNO;
1655
1656         if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK)
1657                 err=UNZ_ERRNO;
1658
1659         if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK)
1660                 err=UNZ_ERRNO;
1661
1662     unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
1663
1664         if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK)
1665                 err=UNZ_ERRNO;
1666
1667         if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK)
1668                 err=UNZ_ERRNO;
1669
1670         if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK)
1671                 err=UNZ_ERRNO;
1672
1673         if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK)
1674                 err=UNZ_ERRNO;
1675
1676         if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK)
1677                 err=UNZ_ERRNO;
1678
1679         if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK)
1680                 err=UNZ_ERRNO;
1681
1682         if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK)
1683                 err=UNZ_ERRNO;
1684
1685         if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK)
1686                 err=UNZ_ERRNO;
1687
1688         if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK)
1689                 err=UNZ_ERRNO;
1690
1691         if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK)
1692                 err=UNZ_ERRNO;
1693
1694         lSeek+=file_info.size_filename;
1695         if ((err==UNZ_OK) && (szFileName!=NULL))
1696         {
1697                 uLong uSizeRead ;
1698                 if (file_info.size_filename<fileNameBufferSize)
1699                 {
1700                         *(szFileName+file_info.size_filename)='\0';
1701                         uSizeRead = file_info.size_filename;
1702                 }
1703                 else
1704                         uSizeRead = fileNameBufferSize;
1705
1706                 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
1707                         if (fread(szFileName,(uInt)uSizeRead,1,s->file)!=1)
1708                                 err=UNZ_ERRNO;
1709                 lSeek -= uSizeRead;
1710         }
1711
1712         
1713         if ((err==UNZ_OK) && (extraField!=NULL))
1714         {
1715                 uLong uSizeRead ;
1716                 if (file_info.size_file_extra<extraFieldBufferSize)
1717                         uSizeRead = file_info.size_file_extra;
1718                 else
1719                         uSizeRead = extraFieldBufferSize;
1720
1721                 if (lSeek!=0)
1722                 {
1723                         if (fseek(s->file,lSeek,SEEK_CUR)==0)
1724                                 lSeek=0;
1725                         else
1726                                 err=UNZ_ERRNO;
1727                 }
1728                 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
1729                         if (fread(extraField,(uInt)uSizeRead,1,s->file)!=1)
1730                                 err=UNZ_ERRNO;
1731                 lSeek += file_info.size_file_extra - uSizeRead;
1732         }
1733         else
1734                 lSeek+=file_info.size_file_extra; 
1735
1736         
1737         if ((err==UNZ_OK) && (szComment!=NULL))
1738         {
1739                 uLong uSizeRead ;
1740                 if (file_info.size_file_comment<commentBufferSize)
1741                 {
1742                         *(szComment+file_info.size_file_comment)='\0';
1743                         uSizeRead = file_info.size_file_comment;
1744                 }
1745                 else
1746                         uSizeRead = commentBufferSize;
1747
1748                 if (lSeek!=0)
1749                 {
1750                         if (fseek(s->file,lSeek,SEEK_CUR)==0)
1751                                 lSeek=0;
1752                         else
1753                                 err=UNZ_ERRNO;
1754                 }
1755                 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
1756                         if (fread(szComment,(uInt)uSizeRead,1,s->file)!=1)
1757                                 err=UNZ_ERRNO;
1758                 lSeek+=file_info.size_file_comment - uSizeRead;
1759         }
1760         else
1761                 lSeek+=file_info.size_file_comment;
1762
1763         if ((err==UNZ_OK) && (pfile_info!=NULL))
1764                 *pfile_info=file_info;
1765
1766         if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
1767                 *pfile_info_internal=file_info_internal;
1768
1769         return err;
1770 }
1771
1772
1773
1774 /*
1775   Write info about the ZipFile in the *pglobal_info structure.
1776   No preparation of the structure is needed
1777   return UNZ_OK if there is no problem.
1778 */
1779 extern int unzGetCurrentFileInfo (      unzFile file, unz_file_info *pfile_info,
1780                                                                         char *szFileName, uLong fileNameBufferSize,
1781                                                                         void *extraField, uLong extraFieldBufferSize,
1782                                                                         char *szComment, uLong commentBufferSize)
1783 {
1784         return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
1785                                                                                                 szFileName,fileNameBufferSize,
1786                                                                                                 extraField,extraFieldBufferSize,
1787                                                                                                 szComment,commentBufferSize);
1788 }
1789
1790 /*
1791   Set the current file of the zipfile to the first file.
1792   return UNZ_OK if there is no problem
1793 */
1794 extern int unzGoToFirstFile (unzFile file)
1795 {
1796         int err=UNZ_OK;
1797         unz_s* s;
1798         if (file==NULL)
1799                 return UNZ_PARAMERROR;
1800         s=(unz_s*)file;
1801         s->pos_in_central_dir=s->offset_central_dir;
1802         s->num_file=0;
1803         err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1804                                                                                          &s->cur_file_info_internal,
1805                                                                                          NULL,0,NULL,0,NULL,0);
1806         s->current_file_ok = (err == UNZ_OK);
1807         return err;
1808 }
1809
1810
1811 /*
1812   Set the current file of the zipfile to the next file.
1813   return UNZ_OK if there is no problem
1814   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
1815 */
1816 extern int unzGoToNextFile (unzFile file)
1817 {
1818         unz_s* s;       
1819         int err;
1820
1821         if (file==NULL)
1822                 return UNZ_PARAMERROR;
1823         s=(unz_s*)file;
1824         if (!s->current_file_ok)
1825                 return UNZ_END_OF_LIST_OF_FILE;
1826         if (s->num_file+1==s->gi.number_entry)
1827                 return UNZ_END_OF_LIST_OF_FILE;
1828
1829         s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
1830                         s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
1831         s->num_file++;
1832         err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1833                                                                                            &s->cur_file_info_internal,
1834                                                                                            NULL,0,NULL,0,NULL,0);
1835         s->current_file_ok = (err == UNZ_OK);
1836         return err;
1837 }
1838
1839
1840 /*
1841   Try locate the file szFileName in the zipfile.
1842   For the iCaseSensitivity signification, see unzipStringFileNameCompare
1843
1844   return value :
1845   UNZ_OK if the file is found. It becomes the current file.
1846   UNZ_END_OF_LIST_OF_FILE if the file is not found
1847 */
1848 extern int unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
1849 {
1850         unz_s* s;       
1851         int err;
1852
1853         
1854         uLong num_fileSaved;
1855         uLong pos_in_central_dirSaved;
1856
1857
1858         if (file==NULL)
1859                 return UNZ_PARAMERROR;
1860
1861     if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
1862         return UNZ_PARAMERROR;
1863
1864         s=(unz_s*)file;
1865         if (!s->current_file_ok)
1866                 return UNZ_END_OF_LIST_OF_FILE;
1867
1868         num_fileSaved = s->num_file;
1869         pos_in_central_dirSaved = s->pos_in_central_dir;
1870
1871         err = unzGoToFirstFile(file);
1872
1873         while (err == UNZ_OK)
1874         {
1875                 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
1876                 unzGetCurrentFileInfo(file,NULL,
1877                                                                 szCurrentFileName,sizeof(szCurrentFileName)-1,
1878                                                                 NULL,0,NULL,0);
1879                 if (unzStringFileNameCompare(szCurrentFileName,
1880                                                                                 szFileName,iCaseSensitivity)==0)
1881                         return UNZ_OK;
1882                 err = unzGoToNextFile(file);
1883         }
1884
1885         s->num_file = num_fileSaved ;
1886         s->pos_in_central_dir = pos_in_central_dirSaved ;
1887         return err;
1888 }
1889
1890
1891 /*
1892   Read the static header of the current zipfile
1893   Check the coherency of the static header and info in the end of central
1894         directory about this file
1895   store in *piSizeVar the size of extra info in static header
1896         (filename and size of extra field data)
1897 */
1898 static int unzlocal_CheckCurrentFileCoherencyHeader (unz_s* s, uInt* piSizeVar,
1899                                                                                                         uLong *poffset_local_extrafield,
1900                                                                                                         uInt *psize_local_extrafield)
1901 {
1902         uLong uMagic,uData,uFlags;
1903         uLong size_filename;
1904         uLong size_extra_field;
1905         int err=UNZ_OK;
1906
1907         *piSizeVar = 0;
1908         *poffset_local_extrafield = 0;
1909         *psize_local_extrafield = 0;
1910
1911         if (fseek(s->file,s->cur_file_info_internal.offset_curfile +
1912                                                                 s->byte_before_the_zipfile,SEEK_SET)!=0)
1913                 return UNZ_ERRNO;
1914
1915
1916         if (err==UNZ_OK)
1917         {
1918                 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
1919                         err=UNZ_ERRNO;
1920                 else if (uMagic!=0x04034b50)
1921                         err=UNZ_BADZIPFILE;
1922         }
1923
1924         if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
1925                 err=UNZ_ERRNO;
1926 /*
1927         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
1928                 err=UNZ_BADZIPFILE;
1929 */
1930         if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK)
1931                 err=UNZ_ERRNO;
1932
1933         if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
1934                 err=UNZ_ERRNO;
1935         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
1936                 err=UNZ_BADZIPFILE;
1937
1938     if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
1939                          (s->cur_file_info.compression_method!=Z_DEFLATED))
1940         err=UNZ_BADZIPFILE;
1941
1942         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */
1943                 err=UNZ_ERRNO;
1944
1945         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */
1946                 err=UNZ_ERRNO;
1947         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
1948                                       ((uFlags & 8)==0))
1949                 err=UNZ_BADZIPFILE;
1950
1951         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */
1952                 err=UNZ_ERRNO;
1953         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
1954                                                           ((uFlags & 8)==0))
1955                 err=UNZ_BADZIPFILE;
1956
1957         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */
1958                 err=UNZ_ERRNO;
1959         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && 
1960                                                           ((uFlags & 8)==0))
1961                 err=UNZ_BADZIPFILE;
1962
1963
1964         if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK)
1965                 err=UNZ_ERRNO;
1966         else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
1967                 err=UNZ_BADZIPFILE;
1968
1969         *piSizeVar += (uInt)size_filename;
1970
1971         if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK)
1972                 err=UNZ_ERRNO;
1973         *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
1974                                                                         SIZEZIPLOCALHEADER + size_filename;
1975         *psize_local_extrafield = (uInt)size_extra_field;
1976
1977         *piSizeVar += (uInt)size_extra_field;
1978
1979         return err;
1980 }
1981                                                                                                 
1982 /*
1983   Open for reading data the current file in the zipfile.
1984   If there is no error and the file is opened, the return value is UNZ_OK.
1985 */
1986 extern int unzOpenCurrentFile (unzFile file)
1987 {
1988         int err=UNZ_OK;
1989         int Store;
1990         uInt iSizeVar;
1991         unz_s* s;
1992         file_in_zip_read_info_s* pfile_in_zip_read_info;
1993         uLong offset_local_extrafield;  /* offset of the static extra field */
1994         uInt  size_local_extrafield;    /* size of the static extra field */
1995
1996         if (file==NULL)
1997                 return UNZ_PARAMERROR;
1998         s=(unz_s*)file;
1999         if (!s->current_file_ok)
2000                 return UNZ_PARAMERROR;
2001
2002     if (s->pfile_in_zip_read != NULL)
2003         unzCloseCurrentFile(file);
2004
2005         if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
2006                                 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
2007                 return UNZ_BADZIPFILE;
2008
2009         pfile_in_zip_read_info = (file_in_zip_read_info_s*)
2010                                                                             safe_malloc(sizeof(file_in_zip_read_info_s));
2011         if (pfile_in_zip_read_info==NULL)
2012                 return UNZ_INTERNALERROR;
2013
2014         pfile_in_zip_read_info->read_buffer=(char*)safe_malloc(UNZ_BUFSIZE);
2015         pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
2016         pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
2017         pfile_in_zip_read_info->pos_local_extrafield=0;
2018
2019         if (pfile_in_zip_read_info->read_buffer==NULL)
2020         {
2021                 free(pfile_in_zip_read_info);
2022                 return UNZ_INTERNALERROR;
2023         }
2024
2025         pfile_in_zip_read_info->stream_initialised=0;
2026         
2027         if ((s->cur_file_info.compression_method!=0) &&
2028         (s->cur_file_info.compression_method!=Z_DEFLATED))
2029                 err=UNZ_BADZIPFILE;
2030         Store = s->cur_file_info.compression_method==0;
2031
2032         pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
2033         pfile_in_zip_read_info->crc32=0;
2034         pfile_in_zip_read_info->compression_method =
2035             s->cur_file_info.compression_method;
2036         pfile_in_zip_read_info->file=s->file;
2037         pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
2038
2039     pfile_in_zip_read_info->stream.total_out = 0;
2040
2041         if (!Store)
2042         {
2043           pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
2044           pfile_in_zip_read_info->stream.zfree = (free_func)0;
2045           pfile_in_zip_read_info->stream.opaque = (voidp)0; 
2046       
2047           err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
2048           if (err == Z_OK)
2049             pfile_in_zip_read_info->stream_initialised=1;
2050         /* windowBits is passed < 0 to tell that there is no zlib header.
2051          * Note that in this case inflate *requires* an extra "dummy" byte
2052          * after the compressed stream in order to complete decompression and
2053          * return Z_STREAM_END. 
2054          * In unzip, i don't wait absolutely Z_STREAM_END because I known the 
2055          * size of both compressed and uncompressed data
2056          */
2057         }
2058         pfile_in_zip_read_info->rest_read_compressed = 
2059             s->cur_file_info.compressed_size ;
2060         pfile_in_zip_read_info->rest_read_uncompressed = 
2061             s->cur_file_info.uncompressed_size ;
2062
2063         
2064         pfile_in_zip_read_info->pos_in_zipfile = 
2065             s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + 
2066                           iSizeVar;
2067         
2068         pfile_in_zip_read_info->stream.avail_in = (uInt)0;
2069
2070
2071         s->pfile_in_zip_read = pfile_in_zip_read_info;
2072     return UNZ_OK;
2073 }
2074
2075
2076 /*
2077   Read bytes from the current file.
2078   buf contain buffer where data must be copied
2079   len the size of buf.
2080
2081   return the number of byte copied if somes bytes are copied
2082   return 0 if the end of file was reached
2083   return <0 with error code if there is an error
2084     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
2085 */
2086 extern int unzReadCurrentFile  (unzFile file, void *buf, unsigned len)
2087 {
2088         int err=UNZ_OK;
2089         uInt iRead = 0;
2090         unz_s* s;
2091         file_in_zip_read_info_s* pfile_in_zip_read_info;
2092         if (file==NULL)
2093                 return UNZ_PARAMERROR;
2094         s=(unz_s*)file;
2095     pfile_in_zip_read_info=s->pfile_in_zip_read;
2096
2097         if (pfile_in_zip_read_info==NULL)
2098                 return UNZ_PARAMERROR;
2099
2100
2101         if ((pfile_in_zip_read_info->read_buffer == NULL))
2102                 return UNZ_END_OF_LIST_OF_FILE;
2103         if (len==0)
2104                 return 0;
2105
2106         pfile_in_zip_read_info->stream.next_out = (Byte*)buf;
2107
2108         pfile_in_zip_read_info->stream.avail_out = (uInt)len;
2109         
2110         if (len>pfile_in_zip_read_info->rest_read_uncompressed)
2111                 pfile_in_zip_read_info->stream.avail_out = 
2112                   (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
2113
2114         while (pfile_in_zip_read_info->stream.avail_out>0)
2115         {
2116                 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
2117             (pfile_in_zip_read_info->rest_read_compressed>0))
2118                 {
2119                         uInt uReadThis = UNZ_BUFSIZE;
2120                         if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
2121                                 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
2122                         if (uReadThis == 0)
2123                                 return UNZ_EOF;
2124                         if (s->cur_file_info.compressed_size == pfile_in_zip_read_info->rest_read_compressed)
2125                                 if (fseek(pfile_in_zip_read_info->file,
2126                                                   pfile_in_zip_read_info->pos_in_zipfile + 
2127                                                          pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0)
2128                                         return UNZ_ERRNO;
2129                         if (fread(pfile_in_zip_read_info->read_buffer,uReadThis,1,
2130                          pfile_in_zip_read_info->file)!=1)
2131                                 return UNZ_ERRNO;
2132                         pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
2133
2134                         pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
2135                         
2136                         pfile_in_zip_read_info->stream.next_in = 
2137                 (Byte*)pfile_in_zip_read_info->read_buffer;
2138                         pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
2139                 }
2140
2141                 if (pfile_in_zip_read_info->compression_method==0)
2142                 {
2143                         uInt uDoCopy,i ;
2144                         if (pfile_in_zip_read_info->stream.avail_out < 
2145                             pfile_in_zip_read_info->stream.avail_in)
2146                                 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
2147                         else
2148                                 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
2149                                 
2150                         for (i=0;i<uDoCopy;i++)
2151                                 *(pfile_in_zip_read_info->stream.next_out+i) =
2152                         *(pfile_in_zip_read_info->stream.next_in+i);
2153                                         
2154                         pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
2155                                                                 pfile_in_zip_read_info->stream.next_out,
2156                                                                 uDoCopy);
2157                         pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
2158                         pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
2159                         pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
2160                         pfile_in_zip_read_info->stream.next_out += uDoCopy;
2161                         pfile_in_zip_read_info->stream.next_in += uDoCopy;
2162             pfile_in_zip_read_info->stream.total_out += uDoCopy;
2163                         iRead += uDoCopy;
2164                 }
2165                 else
2166                 {
2167                         uLong uTotalOutBefore,uTotalOutAfter;
2168                         const Byte *bufBefore;
2169                         uLong uOutThis;
2170                         int flush=Z_SYNC_FLUSH;
2171
2172                         uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
2173                         bufBefore = pfile_in_zip_read_info->stream.next_out;
2174
2175                         /*
2176                         if ((pfile_in_zip_read_info->rest_read_uncompressed ==
2177                                  pfile_in_zip_read_info->stream.avail_out) &&
2178                                 (pfile_in_zip_read_info->rest_read_compressed == 0))
2179                                 flush = Z_FINISH;
2180                         */
2181                         err=inflate(&pfile_in_zip_read_info->stream,flush);
2182
2183                         uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
2184                         uOutThis = uTotalOutAfter-uTotalOutBefore;
2185                         
2186                         pfile_in_zip_read_info->crc32 = 
2187                 crc32(pfile_in_zip_read_info->crc32,bufBefore,
2188                         (uInt)(uOutThis));
2189
2190                         pfile_in_zip_read_info->rest_read_uncompressed -=
2191                 uOutThis;
2192
2193                         iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
2194             
2195                         if (err==Z_STREAM_END)
2196                                 return (iRead==0) ? UNZ_EOF : iRead;
2197                         if (err!=Z_OK) 
2198                                 break;
2199                 }
2200         }
2201
2202         if (err==Z_OK)
2203                 return iRead;
2204         return err;
2205 }
2206
2207
2208 /*
2209   Give the current position in uncompressed data
2210 */
2211 extern long unztell (unzFile file)
2212 {
2213         unz_s* s;
2214         file_in_zip_read_info_s* pfile_in_zip_read_info;
2215         if (file==NULL)
2216                 return UNZ_PARAMERROR;
2217         s=(unz_s*)file;
2218     pfile_in_zip_read_info=s->pfile_in_zip_read;
2219
2220         if (pfile_in_zip_read_info==NULL)
2221                 return UNZ_PARAMERROR;
2222
2223         return (long)pfile_in_zip_read_info->stream.total_out;
2224 }
2225
2226
2227 /*
2228   return 1 if the end of file was reached, 0 elsewhere 
2229 */
2230 extern int unzeof (unzFile file)
2231 {
2232         unz_s* s;
2233         file_in_zip_read_info_s* pfile_in_zip_read_info;
2234         if (file==NULL)
2235                 return UNZ_PARAMERROR;
2236         s=(unz_s*)file;
2237     pfile_in_zip_read_info=s->pfile_in_zip_read;
2238
2239         if (pfile_in_zip_read_info==NULL)
2240                 return UNZ_PARAMERROR;
2241         
2242         if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
2243                 return 1;
2244         else
2245                 return 0;
2246 }
2247
2248
2249
2250 /*
2251   Read extra field from the current file (opened by unzOpenCurrentFile)
2252   This is the static-header version of the extra field (sometimes, there is
2253     more info in the static-header version than in the central-header)
2254
2255   if buf==NULL, it return the size of the static extra field that can be read
2256
2257   if buf!=NULL, len is the size of the buffer, the extra header is copied in
2258         buf.
2259   the return value is the number of bytes copied in buf, or (if <0) 
2260         the error code
2261 */
2262 extern int unzGetLocalExtrafield (unzFile file,void *buf,unsigned len)
2263 {
2264         unz_s* s;
2265         file_in_zip_read_info_s* pfile_in_zip_read_info;
2266         uInt read_now;
2267         uLong size_to_read;
2268
2269         if (file==NULL)
2270                 return UNZ_PARAMERROR;
2271         s=(unz_s*)file;
2272     pfile_in_zip_read_info=s->pfile_in_zip_read;
2273
2274         if (pfile_in_zip_read_info==NULL)
2275                 return UNZ_PARAMERROR;
2276
2277         size_to_read = (pfile_in_zip_read_info->size_local_extrafield - 
2278                                 pfile_in_zip_read_info->pos_local_extrafield);
2279
2280         if (buf==NULL)
2281                 return (int)size_to_read;
2282         
2283         if (len>size_to_read)
2284                 read_now = (uInt)size_to_read;
2285         else
2286                 read_now = (uInt)len ;
2287
2288         if (read_now==0)
2289                 return 0;
2290         
2291         if (fseek(pfile_in_zip_read_info->file,
2292               pfile_in_zip_read_info->offset_local_extrafield + 
2293                           pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
2294                 return UNZ_ERRNO;
2295
2296         if (fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
2297                 return UNZ_ERRNO;
2298
2299         return (int)read_now;
2300 }
2301
2302 /*
2303   Close the file in zip opened with unzipOpenCurrentFile
2304   Return UNZ_CRCERROR if all the file was read but the CRC is not good
2305 */
2306 extern int unzCloseCurrentFile (unzFile file)
2307 {
2308         int err=UNZ_OK;
2309
2310         unz_s* s;
2311         file_in_zip_read_info_s* pfile_in_zip_read_info;
2312         if (file==NULL)
2313                 return UNZ_PARAMERROR;
2314         s=(unz_s*)file;
2315     pfile_in_zip_read_info=s->pfile_in_zip_read;
2316
2317         if (pfile_in_zip_read_info==NULL)
2318                 return UNZ_PARAMERROR;
2319
2320
2321         if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
2322         {
2323                 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
2324                         err=UNZ_CRCERROR;
2325         }
2326
2327
2328         free(pfile_in_zip_read_info->read_buffer);
2329         pfile_in_zip_read_info->read_buffer = NULL;
2330         if (pfile_in_zip_read_info->stream_initialised)
2331                 inflateEnd(&pfile_in_zip_read_info->stream);
2332
2333         pfile_in_zip_read_info->stream_initialised = 0;
2334         free(pfile_in_zip_read_info);
2335
2336     s->pfile_in_zip_read=NULL;
2337
2338         return err;
2339 }
2340
2341
2342 /*
2343   Get the global comment string of the ZipFile, in the szComment buffer.
2344   uSizeBuf is the size of the szComment buffer.
2345   return the number of byte copied or an error code <0
2346 */
2347 extern int unzGetGlobalComment (unzFile file, char *szComment, uLong uSizeBuf)
2348 {
2349         unz_s* s;
2350         uLong uReadThis ;
2351         if (file==NULL)
2352                 return UNZ_PARAMERROR;
2353         s=(unz_s*)file;
2354
2355         uReadThis = uSizeBuf;
2356         if (uReadThis>s->gi.size_comment)
2357                 uReadThis = s->gi.size_comment;
2358
2359         if (fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
2360                 return UNZ_ERRNO;
2361
2362         if (uReadThis>0)
2363     {
2364       *szComment='\0';
2365           if (fread(szComment,(uInt)uReadThis,1,s->file)!=1)
2366                 return UNZ_ERRNO;
2367     }
2368
2369         if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
2370                 *(szComment+s->gi.size_comment)='\0';
2371         return (int)uReadThis;
2372 }
2373
2374 /* crc32.c -- compute the CRC-32 of a data stream
2375  * Copyright (C) 1995-1998 Mark Adler
2376  * For conditions of distribution and use, see copyright notice in zlib.h 
2377  */
2378
2379
2380 #ifdef DYNAMIC_CRC_TABLE
2381
2382 static int crc_table_empty = 1;
2383 static uLong crc_table[256];
2384 static void make_crc_table OF((void));
2385
2386 /*
2387   Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
2388   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.
2389
2390   Polynomials over GF(2) are represented in binary, one bit per coefficient,
2391   with the lowest powers in the most significant bit.  Then adding polynomials
2392   is just exclusive-or, and multiplying a polynomial by x is a right shift by
2393   one.  If we call the above polynomial p, and represent a byte as the
2394   polynomial q, also with the lowest power in the most significant bit (so the
2395   byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
2396   where a mod b means the remainder after dividing a by b.
2397
2398   This calculation is done using the shift-register method of multiplying and
2399   taking the remainder.  The register is initialized to zero, and for each
2400   incoming bit, x^32 is added mod p to the register if the bit is a one (where
2401   x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
2402   x (which is shifting right by one and adding x^32 mod p if the bit shifted
2403   out is a one).  We start with the highest power (least significant bit) of
2404   q and repeat for all eight bits of q.
2405
2406   The table is simply the CRC of all possible eight bit values.  This is all
2407   the information needed to generate CRC's on data a byte at a time for all
2408   combinations of CRC register values and incoming bytes.
2409 */
2410 static void make_crc_table()
2411 {
2412   uLong c;
2413   int n, k;
2414   uLong poly;            /* polynomial exclusive-or pattern */
2415   /* terms of polynomial defining this crc (except x^32): */
2416   static const Byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
2417
2418   /* make exclusive-or pattern from polynomial (0xedb88320L) */
2419   poly = 0L;
2420   for (n = 0; n < sizeof(p)/sizeof(Byte); n++)
2421     poly |= 1L << (31 - p[n]);
2422  
2423   for (n = 0; n < 256; n++)
2424   {
2425     c = (uLong)n;
2426     for (k = 0; k < 8; k++)
2427       c = c & 1 ? poly ^ (c >> 1) : c >> 1;
2428     crc_table[n] = c;
2429   }
2430   crc_table_empty = 0;
2431 }
2432 #else
2433 /* ========================================================================
2434  * Table of CRC-32's of all single-byte values (made by make_crc_table)
2435  */
2436 static const uLong crc_table[256] = {
2437   0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
2438   0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
2439   0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
2440   0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
2441   0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
2442   0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
2443   0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
2444   0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
2445   0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
2446   0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
2447   0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
2448   0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
2449   0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
2450   0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
2451   0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
2452   0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
2453   0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
2454   0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
2455   0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
2456   0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
2457   0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
2458   0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
2459   0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
2460   0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
2461   0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
2462   0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
2463   0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
2464   0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
2465   0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
2466   0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
2467   0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
2468   0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
2469   0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
2470   0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
2471   0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
2472   0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
2473   0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
2474   0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
2475   0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
2476   0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
2477   0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
2478   0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
2479   0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
2480   0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
2481   0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
2482   0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
2483   0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
2484   0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
2485   0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
2486   0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
2487   0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
2488   0x2d02ef8dL
2489 };
2490 #endif
2491
2492 /* =========================================================================
2493  * This function can be used by asm versions of crc32()
2494  */
2495 #ifndef __APPLE__
2496 const uLong * get_crc_table()
2497 {
2498 #ifdef DYNAMIC_CRC_TABLE
2499   if (crc_table_empty) make_crc_table();
2500 #endif
2501   return (const uLong *)crc_table;
2502 }
2503 #endif
2504
2505 /* ========================================================================= */
2506 #define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
2507 #define DO2(buf)  DO1(buf); DO1(buf);
2508 #define DO4(buf)  DO2(buf); DO2(buf);
2509 #define DO8(buf)  DO4(buf); DO4(buf);
2510
2511 /* ========================================================================= */
2512 #ifndef __APPLE__
2513 uLong crc32(uLong crc, const Byte *buf, uInt len)
2514 {
2515     if (buf == Z_NULL) return 0L;
2516 #ifdef DYNAMIC_CRC_TABLE
2517     if (crc_table_empty)
2518       make_crc_table();
2519 #endif
2520     crc = crc ^ 0xffffffffL;
2521     while (len >= 8)
2522     {
2523       DO8(buf);
2524       len -= 8;
2525     }
2526     if (len) do {
2527       DO1(buf);
2528     } while (--len);
2529     return crc ^ 0xffffffffL;
2530 }
2531 #endif
2532
2533 /* infblock.h -- header to use infblock.c
2534  * Copyright (C) 1995-1998 Mark Adler
2535  * For conditions of distribution and use, see copyright notice in zlib.h 
2536  */
2537
2538 /* WARNING: this file should *not* be used by applications. It is
2539    part of the implementation of the compression library and is
2540    subject to change. Applications should only use zlib.h.
2541  */
2542
2543 struct inflate_blocks_state;
2544 typedef struct inflate_blocks_state inflate_blocks_statef;
2545
2546 extern inflate_blocks_statef * inflate_blocks_new OF((
2547     z_streamp z,
2548     check_func c,               /* check function */
2549     uInt w));                   /* window size */
2550
2551 extern int inflate_blocks OF((
2552     inflate_blocks_statef *,
2553     z_streamp ,
2554     int));                      /* initial return code */
2555
2556 extern void inflate_blocks_reset OF((
2557     inflate_blocks_statef *,
2558     z_streamp ,
2559     uLong *));                  /* check value on output */
2560
2561 extern int inflate_blocks_free OF((
2562     inflate_blocks_statef *,
2563     z_streamp));
2564
2565 extern void inflate_set_dictionary OF((
2566     inflate_blocks_statef *s,
2567     const Byte *d,  /* dictionary */
2568     uInt  n));       /* dictionary length */
2569
2570 extern int inflate_blocks_sync_point OF((
2571     inflate_blocks_statef *s));
2572
2573 /* simplify the use of the inflate_huft type with some defines */
2574 #define exop word.what.Exop
2575 #define bits word.what.Bits
2576
2577 /* Table for deflate from PKZIP's appnote.txt. */
2578 static const uInt border[] = { /* Order of the bit length code lengths */
2579         16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
2580
2581 /* inftrees.h -- header to use inftrees.c
2582  * Copyright (C) 1995-1998 Mark Adler
2583  * For conditions of distribution and use, see copyright notice in zlib.h 
2584  */
2585
2586 /* WARNING: this file should *not* be used by applications. It is
2587    part of the implementation of the compression library and is
2588    subject to change. Applications should only use zlib.h.
2589  */
2590
2591 /* Huffman code lookup table entry--this entry is four bytes for machines
2592    that have 16-bit pointers (e.g. PC's in the small or medium model). */
2593
2594 typedef struct inflate_huft_s inflate_huft;
2595
2596 struct inflate_huft_s {
2597   union {
2598     struct {
2599       Byte Exop;        /* number of extra bits or operation */
2600       Byte Bits;        /* number of bits in this code or subcode */
2601     } what;
2602     uInt pad;           /* pad structure to a power of 2 (4 bytes for */
2603   } word;               /*  16-bit, 8 bytes for 32-bit int's) */
2604   uInt base;            /* literal, length base, distance base,
2605                            or table offset */
2606 };
2607
2608 /* Maximum size of dynamic tree.  The maximum found in a long but non-
2609    exhaustive search was 1004 huft structures (850 for length/literals
2610    and 154 for distances, the latter actually the result of an
2611    exhaustive search).  The actual maximum is not known, but the
2612    value below is more than safe. */
2613 #define MANY 1440
2614
2615 extern int inflate_trees_bits OF((
2616     uInt *,                    /* 19 code lengths */
2617     uInt *,                    /* bits tree desired/actual depth */
2618     inflate_huft * *,       /* bits tree result */
2619     inflate_huft *,             /* space for trees */
2620     z_streamp));                /* for messages */
2621
2622 extern int inflate_trees_dynamic OF((
2623     uInt,                       /* number of literal/length codes */
2624     uInt,                       /* number of distance codes */
2625     uInt *,                    /* that many (total) code lengths */
2626     uInt *,                    /* literal desired/actual bit depth */
2627     uInt *,                    /* distance desired/actual bit depth */
2628     inflate_huft * *,       /* literal/length tree result */
2629     inflate_huft * *,       /* distance tree result */
2630     inflate_huft *,             /* space for trees */
2631     z_streamp));                /* for messages */
2632
2633 extern int inflate_trees_fixed OF((
2634     uInt *,                    /* literal desired/actual bit depth */
2635     uInt *,                    /* distance desired/actual bit depth */
2636     inflate_huft * *,       /* literal/length tree result */
2637     inflate_huft * *,       /* distance tree result */
2638     z_streamp));                /* for memory allocation */
2639
2640
2641 /* infcodes.h -- header to use infcodes.c
2642  * Copyright (C) 1995-1998 Mark Adler
2643  * For conditions of distribution and use, see copyright notice in zlib.h 
2644  */
2645
2646 /* WARNING: this file should *not* be used by applications. It is
2647    part of the implementation of the compression library and is
2648    subject to change. Applications should only use zlib.h.
2649  */
2650
2651 struct inflate_codes_state;
2652 typedef struct inflate_codes_state inflate_codes_statef;
2653
2654 extern inflate_codes_statef *inflate_codes_new OF((
2655     uInt, uInt,
2656     inflate_huft *, inflate_huft *,
2657     z_streamp ));
2658
2659 extern int inflate_codes OF((
2660     inflate_blocks_statef *,
2661     z_streamp ,
2662     int));
2663
2664 extern void inflate_codes_free OF((
2665     inflate_codes_statef *,
2666     z_streamp ));
2667
2668 /* infutil.h -- types and macros common to blocks and codes
2669  * Copyright (C) 1995-1998 Mark Adler
2670  * For conditions of distribution and use, see copyright notice in zlib.h 
2671  */
2672
2673 /* WARNING: this file should *not* be used by applications. It is
2674    part of the implementation of the compression library and is
2675    subject to change. Applications should only use zlib.h.
2676  */
2677
2678 #ifndef _INFUTIL_H
2679 #define _INFUTIL_H
2680
2681 typedef enum {
2682       TYPE,     /* get type bits (3, including end bit) */
2683       LENS,     /* get lengths for stored */
2684       STORED,   /* processing stored block */
2685       TABLE,    /* get table lengths */
2686       BTREE,    /* get bit lengths tree for a dynamic block */
2687       DTREE,    /* get length, distance trees for a dynamic block */
2688       CODES,    /* processing fixed or dynamic block */
2689       DRY,      /* output remaining window bytes */
2690       DONE,     /* finished last block, done */
2691       BAD}      /* got a data error--stuck here */
2692 inflate_block_mode;
2693
2694 /* inflate blocks semi-private state */
2695 struct inflate_blocks_state {
2696
2697   /* mode */
2698   inflate_block_mode  mode;     /* current inflate_block mode */
2699
2700   /* mode dependent information */
2701   union {
2702     uInt left;          /* if STORED, bytes left to copy */
2703     struct {
2704       uInt table;               /* table lengths (14 bits) */
2705       uInt index;               /* index into blens (or border) */
2706       uInt *blens;             /* bit lengths of codes */
2707       uInt bb;                  /* bit length tree depth */
2708       inflate_huft *tb;         /* bit length decoding tree */
2709     } trees;            /* if DTREE, decoding info for trees */
2710     struct {
2711       inflate_codes_statef 
2712          *codes;
2713     } decode;           /* if CODES, current state */
2714   } sub;                /* submode */
2715   uInt last;            /* true if this block is the last block */
2716
2717   /* mode independent information */
2718   uInt bitk;            /* bits in bit buffer */
2719   uLong bitb;           /* bit buffer */
2720   inflate_huft *hufts;  /* single safe_malloc for tree space */
2721   Byte *window;        /* sliding window */
2722   Byte *end;           /* one byte after sliding window */
2723   Byte *read;          /* window read pointer */
2724   Byte *write;         /* window write pointer */
2725   check_func checkfn;   /* check function */
2726   uLong check;          /* check on output */
2727
2728 };
2729
2730
2731 /* defines for inflate input/output */
2732 /*   update pointers and return */
2733 #define UPDBITS {s->bitb=b;s->bitk=k;}
2734 #define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;}
2735 #define UPDOUT {s->write=q;}
2736 #define UPDATE {UPDBITS UPDIN UPDOUT}
2737 #define LEAVE {UPDATE return inflate_flush(s,z,r);}
2738 /*   get bytes and bits */
2739 #define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;}
2740 #define NEEDBYTE {if(n)r=Z_OK;else LEAVE}
2741 #define NEXTBYTE (n--,*p++)
2742 #define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}}
2743 #define DUMPBITS(j) {b>>=(j);k-=(j);}
2744 /*   output bytes */
2745 #define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q)
2746 #define LOADOUT {q=s->write;m=(uInt)WAVAIL;}
2747 #define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}}
2748 #define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT}
2749 #define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;}
2750 #define OUTBYTE(a) {*q++=(Byte)(a);m--;}
2751 /*   load static pointers */
2752 #define LOAD {LOADIN LOADOUT}
2753
2754 /* masks for lower bits (size given to avoid silly warnings with Visual C++) */
2755 extern uInt inflate_mask[17];
2756
2757 /* copy as much as possible from the sliding window to the output area */
2758 extern int inflate_flush OF((
2759     inflate_blocks_statef *,
2760     z_streamp ,
2761     int));
2762
2763 #endif
2764
2765                                                                 
2766 /*
2767    Notes beyond the 1.93a appnote.txt:
2768
2769    1. Distance pointers never point before the beginning of the output
2770       stream.
2771    2. Distance pointers can point back across blocks, up to 32k away.
2772    3. There is an implied maximum of 7 bits for the bit length table and
2773       15 bits for the actual data.
2774    4. If only one code exists, then it is encoded using one bit.  (Zero
2775       would be more efficient, but perhaps a little confusing.)  If two
2776       codes exist, they are coded using one bit each (0 and 1).
2777    5. There is no way of sending zero distance codes--a dummy must be
2778       sent if there are none.  (History: a pre 2.0 version of PKZIP would
2779       store blocks with no distance codes, but this was discovered to be
2780       too harsh a criterion.)  Valid only for 1.93a.  2.04c does allow
2781       zero distance codes, which is sent as one code of zero bits in
2782       length.
2783    6. There are up to 286 literal/length codes.  Code 256 represents the
2784       end-of-block.  Note however that the static length tree defines
2785       288 codes just to fill out the Huffman codes.  Codes 286 and 287
2786       cannot be used though, since there is no length base or extra bits
2787       defined for them.  Similarily, there are up to 30 distance codes.
2788       However, static trees define 32 codes (all 5 bits) to fill out the
2789       Huffman codes, but the last two had better not show up in the data.
2790    7. Unzip can check dynamic Huffman blocks for complete code sets.
2791       The exception is that a single code would not be complete (see #4).
2792    8. The five bits following the block type is really the number of
2793       literal codes sent minus 257.
2794    9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
2795       (1+6+6).  Therefore, to output three times the length, you output
2796       three codes (1+1+1), whereas to output four times the same length,
2797       you only need two codes (1+3).  Hmm.
2798   10. In the tree reconstruction algorithm, Code = Code + Increment
2799       only if BitLength(i) is not zero.  (Pretty obvious.)
2800   11. Correction: 4 Bits: # of Bit Length codes - 4     (4 - 19)
2801   12. Note: length code 284 can represent 227-258, but length code 285
2802       really is 258.  The last length deserves its own, short code
2803       since it gets used a lot in very redundant files.  The length
2804       258 is special since 258 - 3 (the min match length) is 255.
2805   13. The literal/length and distance code bit lengths are read as a
2806       single stream of lengths.  It is possible (and advantageous) for
2807       a repeat code (16, 17, or 18) to go across the boundary between
2808       the two sets of lengths.
2809  */
2810
2811
2812 #ifndef __APPLE__
2813 void inflate_blocks_reset(inflate_blocks_statef *s, z_streamp z, uLong *c)
2814 {
2815   if (c != Z_NULL)
2816     *c = s->check;
2817   if (s->mode == BTREE || s->mode == DTREE)
2818     ZFREE(z, s->sub.trees.blens);
2819   if (s->mode == CODES)
2820     inflate_codes_free(s->sub.decode.codes, z);
2821   s->mode = TYPE;
2822   s->bitk = 0;
2823   s->bitb = 0;
2824   s->read = s->write = s->window;
2825   if (s->checkfn != Z_NULL)
2826     z->adler = s->check = (*s->checkfn)(0L, (const Byte *)Z_NULL, 0);
2827   Tracev(("inflate:   blocks reset\n"));
2828 }
2829 #endif
2830
2831 #ifndef __APPLE__
2832 inflate_blocks_statef *inflate_blocks_new(z_streamp z, check_func c, uInt w)
2833 {
2834   inflate_blocks_statef *s;
2835
2836   if ((s = (inflate_blocks_statef *)ZALLOC
2837        (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
2838     return s;
2839   if ((s->hufts =
2840        (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL)
2841   {
2842     ZFREE(z, s);
2843     return Z_NULL;
2844   }
2845   if ((s->window = (Byte *)ZALLOC(z, 1, w)) == Z_NULL)
2846   {
2847     ZFREE(z, s->hufts);
2848     ZFREE(z, s);
2849     return Z_NULL;
2850   }
2851   s->end = s->window + w;
2852   s->checkfn = c;
2853   s->mode = TYPE;
2854   Tracev(("inflate:   blocks allocated\n"));
2855   inflate_blocks_reset(s, z, Z_NULL);
2856   return s;
2857 }
2858 #endif
2859
2860 #ifndef __APPLE__
2861 int inflate_blocks(inflate_blocks_statef *s, z_streamp z, int r)
2862 {
2863   uInt t;               /* temporary storage */
2864   uLong b;              /* bit buffer */
2865   uInt k;               /* bits in bit buffer */
2866   Byte *p;             /* input data pointer */
2867   uInt n;               /* bytes available there */
2868   Byte *q;             /* output window write pointer */
2869   uInt m;               /* bytes to end of window or read pointer */
2870
2871   /* copy input/output information to locals (UPDATE macro restores) */
2872   LOAD
2873
2874   /* process input based on current state */
2875   while (1) switch (s->mode)
2876   {
2877     case TYPE:
2878       NEEDBITS(3)
2879       t = (uInt)b & 7;
2880       s->last = t & 1;
2881       switch (t >> 1)
2882       {
2883         case 0:                         /* stored */
2884           Tracev(("inflate:     stored block%s\n",
2885                  s->last ? " (last)" : ""));
2886           DUMPBITS(3)
2887           t = k & 7;                    /* go to byte boundary */
2888           DUMPBITS(t)
2889           s->mode = LENS;               /* get length of stored block */
2890           break;
2891         case 1:                         /* fixed */
2892           Tracev(("inflate:     fixed codes block%s\n",
2893                  s->last ? " (last)" : ""));
2894           {
2895             uInt bl, bd;
2896             inflate_huft *tl, *td;
2897
2898             inflate_trees_fixed(&bl, &bd, &tl, &td, z);
2899             s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
2900             if (s->sub.decode.codes == Z_NULL)
2901             {
2902               r = Z_MEM_ERROR;
2903               LEAVE
2904             }
2905           }
2906           DUMPBITS(3)
2907           s->mode = CODES;
2908           break;
2909         case 2:                         /* dynamic */
2910           Tracev(("inflate:     dynamic codes block%s\n",
2911                  s->last ? " (last)" : ""));
2912           DUMPBITS(3)
2913           s->mode = TABLE;
2914           break;
2915         case 3:                         /* illegal */
2916           DUMPBITS(3)
2917           s->mode = BAD;
2918           z->msg = (char*)"invalid block type";
2919           r = Z_DATA_ERROR;
2920           LEAVE
2921       }
2922       break;
2923     case LENS:
2924       NEEDBITS(32)
2925       if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
2926       {
2927         s->mode = BAD;
2928         z->msg = (char*)"invalid stored block lengths";
2929         r = Z_DATA_ERROR;
2930         LEAVE
2931       }
2932       s->sub.left = (uInt)b & 0xffff;
2933       b = k = 0;                      /* dump bits */
2934       Tracev(("inflate:       stored length %u\n", s->sub.left));
2935       s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE);
2936       break;
2937     case STORED:
2938       if (n == 0)
2939         LEAVE
2940       NEEDOUT
2941       t = s->sub.left;
2942       if (t > n) t = n;
2943       if (t > m) t = m;
2944       zmemcpy(q, p, t);
2945       p += t;  n -= t;
2946       q += t;  m -= t;
2947       if ((s->sub.left -= t) != 0)
2948         break;
2949       Tracev(("inflate:       stored end, %lu total out\n",
2950               z->total_out + (q >= s->read ? q - s->read :
2951               (s->end - s->read) + (q - s->window))));
2952       s->mode = s->last ? DRY : TYPE;
2953       break;
2954     case TABLE:
2955       NEEDBITS(14)
2956       s->sub.trees.table = t = (uInt)b & 0x3fff;
2957 #ifndef PKZIP_BUG_WORKAROUND
2958       if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
2959       {
2960         s->mode = BAD;
2961         z->msg = (char*)"too many length or distance symbols";
2962         r = Z_DATA_ERROR;
2963         LEAVE
2964       }
2965 #endif
2966       t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
2967       if ((s->sub.trees.blens = (uInt*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
2968       {
2969         r = Z_MEM_ERROR;
2970         LEAVE
2971       }
2972       DUMPBITS(14)
2973       s->sub.trees.index = 0;
2974       Tracev(("inflate:       table sizes ok\n"));
2975       s->mode = BTREE;
2976     case BTREE:
2977       while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
2978       {
2979         NEEDBITS(3)
2980         s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
2981         DUMPBITS(3)
2982       }
2983       while (s->sub.trees.index < 19)
2984         s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
2985       s->sub.trees.bb = 7;
2986       t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
2987                              &s->sub.trees.tb, s->hufts, z);
2988       if (t != Z_OK)
2989       {
2990         ZFREE(z, s->sub.trees.blens);
2991         r = t;
2992         if (r == Z_DATA_ERROR)
2993           s->mode = BAD;
2994         LEAVE
2995       }
2996       s->sub.trees.index = 0;
2997       Tracev(("inflate:       bits tree ok\n"));
2998       s->mode = DTREE;
2999     case DTREE:
3000       while (t = s->sub.trees.table,
3001              s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
3002       {
3003         inflate_huft *h;
3004         uInt i, j, c;
3005
3006         t = s->sub.trees.bb;
3007         NEEDBITS(t)
3008         h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
3009         t = h->bits;
3010         c = h->base;
3011         if (c < 16)
3012         {
3013           DUMPBITS(t)
3014           s->sub.trees.blens[s->sub.trees.index++] = c;
3015         }
3016         else /* c == 16..18 */
3017         {
3018           i = c == 18 ? 7 : c - 14;
3019           j = c == 18 ? 11 : 3;
3020           NEEDBITS(t + i)
3021           DUMPBITS(t)
3022           j += (uInt)b & inflate_mask[i];
3023           DUMPBITS(i)
3024           i = s->sub.trees.index;
3025           t = s->sub.trees.table;
3026           if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
3027               (c == 16 && i < 1))
3028           {
3029             ZFREE(z, s->sub.trees.blens);
3030             s->mode = BAD;
3031             z->msg = (char*)"invalid bit length repeat";
3032             r = Z_DATA_ERROR;
3033             LEAVE
3034           }
3035           c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
3036           do {
3037             s->sub.trees.blens[i++] = c;
3038           } while (--j);
3039           s->sub.trees.index = i;
3040         }
3041       }
3042       s->sub.trees.tb = Z_NULL;
3043       {
3044         uInt bl, bd;
3045         inflate_huft *tl, *td;
3046         inflate_codes_statef *c;
3047
3048         bl = 9;         /* must be <= 9 for lookahead assumptions */
3049         bd = 6;         /* must be <= 9 for lookahead assumptions */
3050         t = s->sub.trees.table;
3051         t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
3052                                   s->sub.trees.blens, &bl, &bd, &tl, &td,
3053                                   s->hufts, z);
3054         ZFREE(z, s->sub.trees.blens);
3055         if (t != Z_OK)
3056         {
3057           if (t == (uInt)Z_DATA_ERROR)
3058             s->mode = BAD;
3059           r = t;
3060           LEAVE
3061         }
3062         Tracev(("inflate:       trees ok\n"));
3063         if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
3064         {
3065           r = Z_MEM_ERROR;
3066           LEAVE
3067         }
3068         s->sub.decode.codes = c;
3069       }
3070       s->mode = CODES;
3071     case CODES:
3072       UPDATE
3073       if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
3074         return inflate_flush(s, z, r);
3075       r = Z_OK;
3076       inflate_codes_free(s->sub.decode.codes, z);
3077       LOAD
3078       Tracev(("inflate:       codes end, %lu total out\n",
3079               z->total_out + (q >= s->read ? q - s->read :
3080               (s->end - s->read) + (q - s->window))));
3081       if (!s->last)
3082       {
3083         s->mode = TYPE;
3084         break;
3085       }
3086       s->mode = DRY;
3087     case DRY:
3088       FLUSH
3089       if (s->read != s->write)
3090         LEAVE
3091       s->mode = DONE;
3092     case DONE:
3093       r = Z_STREAM_END;
3094       LEAVE
3095     case BAD:
3096       r = Z_DATA_ERROR;
3097       LEAVE
3098     default:
3099       r = Z_STREAM_ERROR;
3100       LEAVE
3101   }
3102 }
3103 #endif
3104
3105 #ifndef __APPLE__
3106 int inflate_blocks_free(inflate_blocks_statef *s, z_streamp z)
3107 {
3108   inflate_blocks_reset(s, z, Z_NULL);
3109   ZFREE(z, s->window);
3110   ZFREE(z, s->hufts);
3111   ZFREE(z, s);
3112   Tracev(("inflate:   blocks freed\n"));
3113   return Z_OK;
3114 }
3115 #endif
3116
3117 #ifndef __APPLE__
3118 void inflate_set_dictionary(inflate_blocks_statef *s, const Byte *d, uInt n)
3119 {
3120   zmemcpy(s->window, d, n);
3121   s->read = s->write = s->window + n;
3122 }
3123 #endif
3124
3125 /* Returns true if inflate is currently at the end of a block generated
3126  * by Z_SYNC_FLUSH or Z_FULL_FLUSH. 
3127  * IN assertion: s != Z_NULL
3128  */
3129 #ifndef __APPLE__
3130 int inflate_blocks_sync_point(inflate_blocks_statef *s)
3131 {
3132   return s->mode == LENS;
3133 }
3134 #endif
3135
3136 /* And'ing with mask[n] masks the lower n bits */
3137 uInt inflate_mask[17] = {
3138     0x0000,
3139     0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
3140     0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
3141 };
3142
3143 /* copy as much as possible from the sliding window to the output area */
3144 #ifndef __APPLE__
3145 int inflate_flush(inflate_blocks_statef *s, z_streamp z, int r)
3146 {
3147   uInt n;
3148   Byte *p;
3149   Byte *q;
3150
3151   /* static copies of source and destination pointers */
3152   p = z->next_out;
3153   q = s->read;
3154
3155   /* compute number of bytes to copy as as end of window */
3156   n = (uInt)((q <= s->write ? s->write : s->end) - q);
3157   if (n > z->avail_out) n = z->avail_out;
3158   if (n && r == Z_BUF_ERROR) r = Z_OK;
3159
3160   /* update counters */
3161   z->avail_out -= n;
3162   z->total_out += n;
3163
3164   /* update check information */
3165   if (s->checkfn != Z_NULL)
3166     z->adler = s->check = (*s->checkfn)(s->check, q, n);
3167
3168   /* copy as as end of window */
3169   zmemcpy(p, q, n);
3170   p += n;
3171   q += n;
3172
3173   /* see if more to copy at beginning of window */
3174   if (q == s->end)
3175   {
3176     /* wrap pointers */
3177     q = s->window;
3178     if (s->write == s->end)
3179       s->write = s->window;
3180
3181     /* compute bytes to copy */
3182     n = (uInt)(s->write - q);
3183     if (n > z->avail_out) n = z->avail_out;
3184     if (n && r == Z_BUF_ERROR) r = Z_OK;
3185
3186     /* update counters */
3187     z->avail_out -= n;
3188     z->total_out += n;
3189
3190     /* update check information */
3191     if (s->checkfn != Z_NULL)
3192       z->adler = s->check = (*s->checkfn)(s->check, q, n);
3193
3194     /* copy */
3195     zmemcpy(p, q, n);
3196     p += n;
3197     q += n;
3198   }
3199
3200   /* update pointers */
3201   z->next_out = p;
3202   s->read = q;
3203
3204   /* done */
3205   return r;
3206 }
3207 #endif
3208
3209 /* inftrees.c -- generate Huffman trees for efficient decoding
3210  * Copyright (C) 1995-1998 Mark Adler
3211  * For conditions of distribution and use, see copyright notice in zlib.h 
3212  */
3213
3214 #ifndef __APPLE__
3215 const char inflate_copyright[] =
3216    " inflate 1.1.3 Copyright 1995-1998 Mark Adler ";
3217 #endif
3218
3219 /*
3220   If you use the zlib library in a product, an acknowledgment is welcome
3221   in the documentation of your product. If for some reason you cannot
3222   include such an acknowledgment, I would appreciate that you keep this
3223   copyright string in the executable of your product.
3224  */
3225
3226 /* simplify the use of the inflate_huft type with some defines */
3227 #define exop word.what.Exop
3228 #define bits word.what.Bits
3229
3230
3231 static int huft_build OF((
3232     uInt *,                             /* code lengths in bits */
3233     uInt,               /* number of codes */
3234     uInt,               /* number of "simple" codes */
3235     const uInt *,               /* list of base values for non-simple codes */
3236     const uInt *,               /* list of extra bits for non-simple codes */
3237     inflate_huft **,    /* result: starting table */
3238     uInt *,                             /* maximum lookup bits (returns actual) */
3239     inflate_huft *,     /* space for trees */
3240     uInt *,             /* hufts used in space */
3241     uInt * ));                  /* space for values */
3242
3243 /* Tables for deflate from PKZIP's appnote.txt. */
3244 static const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
3245         3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
3246         35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
3247         /* see note #13 above about 258 */
3248 static const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
3249         0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
3250         3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112}; /* 112==invalid */
3251 static const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
3252         1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
3253         257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
3254         8193, 12289, 16385, 24577};
3255 static const uInt cpdext[30] = { /* Extra bits for distance codes */
3256         0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
3257         7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
3258         12, 12, 13, 13};
3259
3260 /*
3261    Huffman code decoding is performed using a multi-level table lookup.
3262    The fastest way to decode is to simply build a lookup table whose
3263    size is determined by the longest code.  However, the time it takes
3264    to build this table can also be a factor if the data being decoded
3265    is not very long.  The most common codes are necessarily the
3266    shortest codes, so those codes dominate the decoding time, and hence
3267    the speed.  The idea is you can have a shorter table that decodes the
3268    shorter, more probable codes, and then point to subsidiary tables for
3269    the longer codes.  The time it costs to decode the longer codes is
3270    then traded against the time it takes to make longer tables.
3271
3272    This results of this trade are in the variables lbits and dbits
3273    below.  lbits is the number of bits the first level table for literal/
3274    length codes can decode in one step, and dbits is the same thing for
3275    the distance codes.  Subsequent tables are also less than or equal to
3276    those sizes.  These values may be adjusted either when all of the
3277    codes are shorter than that, in which case the longest code length in
3278    bits is used, or when the shortest code is *longer* than the requested
3279    table size, in which case the length of the shortest code in bits is
3280    used.
3281
3282    There are two different values for the two tables, since they code a
3283    different number of possibilities each.  The literal/length table
3284    codes 286 possible values, or in a flat code, a little over eight
3285    bits.  The distance table codes 30 possible values, or a little less
3286    than five bits, flat.  The optimum values for speed end up being
3287    about one bit more than those, so lbits is 8+1 and dbits is 5+1.
3288    The optimum values may differ though from machine to machine, and
3289    possibly even between compilers.  Your mileage may vary.
3290  */
3291
3292
3293 /* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
3294 #define BMAX 15         /* maximum bit length of any code */
3295
3296 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)
3297 //uInt *b;               /* code lengths in bits (all assumed <= BMAX) */
3298 //uInt n;                 /* number of codes (assumed <= 288) */
3299 //uInt s;                 /* number of simple-valued codes (0..s-1) */
3300 //const uInt *d;         /* list of base values for non-simple codes */
3301 //const uInt *e;         /* list of extra bits for non-simple codes */
3302 //inflate_huft ** t;            /* result: starting table */
3303 //uInt *m;               /* maximum lookup bits, returns actual */
3304 //inflate_huft *hp;       /* space for trees */
3305 //uInt *hn;               /* hufts used in space */
3306 //uInt *v;               /* working area: values in order of bit length */
3307 /* Given a list of code lengths and a maximum table size, make a set of
3308    tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
3309    if the given code set is incomplete (the tables are still built in this
3310    case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
3311    lengths), or Z_MEM_ERROR if not enough memory. */
3312 {
3313
3314   uInt a;                       /* counter for codes of length k */
3315   uInt c[BMAX+1];               /* bit length count table */
3316   uInt f;                       /* i repeats in table every f entries */
3317   int g;                        /* maximum code length */
3318   int h;                        /* table level */
3319   register uInt i;              /* counter, current code */
3320   register uInt j;              /* counter */
3321   register int k;               /* number of bits in current code */
3322   int l;                        /* bits per table (returned in m) */
3323   uInt mask;                    /* (1 << w) - 1, to avoid cc -O bug on HP */
3324   register uInt *p;            /* pointer into c[], b[], or v[] */
3325   inflate_huft *q;              /* points to current table */
3326   struct inflate_huft_s r;      /* table entry for structure assignment */
3327   inflate_huft *u[BMAX];        /* table stack */
3328   register int w;               /* bits before this table == (l * h) */
3329   uInt x[BMAX+1];               /* bit offsets, then code stack */
3330   uInt *xp;                    /* pointer into x */
3331   int y;                        /* number of dummy codes added */
3332   uInt z;                       /* number of entries in current table */
3333
3334
3335   /* Generate counts for each bit length */
3336   p = c;
3337 #define C0 *p++&nbs