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