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