plugins/vfspk3/unzip.cpp

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