src/cmd/INIT/ratz.c

   1 /*
   2  * ratz -- read a tar gzip archive from the standard input
   3  *
   4  * coded for portability
   5  * _SEAR_* macros for win32 self extracting archives -- see sear(1).
   6  */
   7
   8 static char id[] = "\n@(#)$Id: ratz (Jean-loup Gailly, Mark Adler, Glenn Fowler) 1.2.3 2010-10-10 $\0\n";
   9
  10 #if _PACKAGE_ast
  11
  12 #include <ast.h>
  13 #include <error.h>
  14
  15 static const char usage[] =
  16 "[-?\n@(#)$Id: ratz (Jean-loup Gailly, Mark Adler, Glenn Fowler) 1.2.3 2010-10-10 $\n]"
  17 "[-author?Jean-loup Gailly]"
  18 "[-author?Mark Adler]"
  19 "[-author?Glenn Fowler <gsf@research.att.com>]"
  20 "[-copyright?Copyright (c) 1995-2005 Jean-loup Gailly and Mark Adler]"
  21 "[-license?http://www.opensource.org/licenses/zlib-license]"
  22 "[+NAME?ratz - read a tar gzip archive]"
  23 "[+DESCRIPTION?\bratz\b extracts files and directories from a tar gzip"
  24 "       archive on the standard input. It is a standalone program for systems"
  25 "       that do not have \bpax\b(1), \btar\b(1) or \bgunzip\b(1). Only regular"
  26 "       files and directories are extracted; all other file types are ignored.]"
  27 "[+?\b.exe\b files generated by \bsear\b(1) are fully functional \bratz\b"
  28 "       executables, so any \bratz\b option may be used on a \bsear\b file."
  29 "       This allows \bsear\b file contents to be examined and extracted without"
  30 "       executing any embedded installation scripts.]"
  31 "[c:cat|uncompress?Uncompress the standard input and copy it to the standard"
  32 "       output.]"
  33 #if defined(_SEAR_EXEC) || defined(_SEAR_SEEK)
  34 "[i!:install?Execute the sear installation script.]"
  35 "[k:keep?Keep the installation temporary directory.]"
  36 #endif
  37 "[l:local?Reject files that traverse outside the current directory.]"
  38 "[m:meter?Display a one line text meter showing archive read progress.]"
  39 "[n!:convert?In ebcdic environments convert text archive members from ascii"
  40 "       to the native ebcdic.]"
  41 "[t:list?List each file path on the standard output but do not extract.]"
  42 "[v:verbose?List each file path on the standard output as it is extracted.]"
  43 "[V?Print the program version and exit.]"
  44 "[+SEE ALSO?\bgunzip\b(1), \bpackage\b(1), \bpax\b(1), \bsear\b(1), \btar\b(1)]"
  45 ;
  46
  47 #else
  48
  49 #define NiL             ((char*)0)
  50
  51 #endif
  52
  53 #define METER_width     80
  54 #define METER_parts     20
  55
  56 #ifndef _GUNZIP_H
  57 #define _GUNZIP_H       1
  58
  59 /*
  60  * stripped down zlib containing public gzfopen()+gzread() in one file
  61  * USE THE REAL ZLIB AFTER BOOTSTRAP
  62  */
  63
  64 #define ZLIB_INTERNAL   1
  65 #define NO_GZCOMPRESS   1
  66
  67 #define gz_headerp      voidp
  68
  69 #include <stdio.h>
  70 #include <sys/types.h>
  71
  72 #if _PACKAGE_ast || defined(__STDC__) || defined(_SEAR_EXEC) || defined(_WIN32)
  73
  74 #define FOPEN_READ      "rb"
  75 #define FOPEN_WRITE     "wb"
  76
  77 #else
  78
  79 #define FOPEN_READ      "r"
  80 #define FOPEN_WRITE     "w"
  81
  82 #endif
  83
  84 #ifndef O_BINARY
  85 #define O_BINARY        0
  86 #endif
  87
  88 #if _PACKAGE_ast
  89
  90 #ifndef setmode
  91 #define setmode(d,m)
  92 #endif
  93
  94 #else
  95
  96 #if !defined(_WINIX) && (_UWIN || __CYGWIN__ || __EMX__)
  97 #define _WINIX          1
  98 #endif
  99
 100 #if _WIN32 && !_WINIX
 101
 102 #include <direct.h>
 103 #include <io.h>
 104 #include <fcntl.h>
 105 #include <windows.h>
 106
 107 #define access          _access
 108 #define chmod           _chmod
 109 #define close           _close
 110 #define dup             _dup
 111 #define lseek           _lseek
 112 #define open            _open
 113 #define read            _read
 114 #define setmode         _setmode
 115 #define unlink          _unlink
 116
 117 #define mkdir(a,b)      _mkdir(a)
 118
 119 #else
 120
 121 #define HAVE_UNISTD_H   1
 122
 123 #include <unistd.h>
 124 #include <errno.h>
 125
 126 #ifndef setmode
 127 #define setmode(d,m)
 128 #endif
 129
 130 #endif
 131
 132 #if defined(__STDC__)
 133
 134 #include <stdlib.h>
 135 #include <string.h>
 136
 137 #endif
 138
 139 #endif
 140
 141 #ifndef _ZLIB_H
 142 #define _ZLIB_H         1
 143
 144 /* zlib.h -- interface of the 'zlib' general purpose compression library
 145   version 1.2.3, July 18th, 2005
 146
 147   Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
 148
 149   This software is provided 'as-is', without any express or implied
 150   warranty.  In no event will the authors be held liable for any damages
 151   arising from the use of this software.
 152
 153   Permission is granted to anyone to use this software for any purpose,
 154   including commercial applications, and to alter it and redistribute it
 155   freely, subject to the following restrictions:
 156
 157   1. The origin of this software must not be misrepresented; you must not
 158      claim that you wrote the original software. If you use this software
 159      in a product, an acknowledgment in the product documentation would be
 160      appreciated but is not required.
 161   2. Altered source versions must be plainly marked as such, and must not be
 162      misrepresented as being the original software.
 163   3. This notice may not be removed or altered from any source distribution.
 164
 165   Jean-loup Gailly        Mark Adler
 166   jloup@gzip.org          madler@alumni.caltech.edu
 167
 168
 169   The data format used by the zlib library is described by RFCs (Request for
 170   Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
 171   (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
 172 */
 173
 174 #ifndef _ZCONF_H
 175 #define _ZCONF_H        1
 176
 177 #if _PACKAGE_ast
 178 #include <ast_std.h>    /* for { _WINIX __IMPORT__ __EXPORT__ } */
 179 #define z_off_t         int32_t
 180 #if _typ_int64_t
 181 #define z_off64_t       int64_t
 182 #endif
 183 #else
 184 #if !defined(_WINIX) && (_UWIN || __CYGWIN__ || __EMX__)
 185 #define _WINIX          1
 186 #endif
 187 #endif
 188
 189 #if _BLD_z && defined(__EXPORT__)
 190 #define ZEXTERN         __EXPORT__
 191 #define ZEXPORT
 192 #endif
 193
 194 #if defined(__MSDOS__) && !defined(MSDOS)
 195 #  define MSDOS
 196 #endif
 197 #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
 198 #  define OS2
 199 #endif
 200 #if defined(_WINDOWS) && !defined(WINDOWS)
 201 #  define WINDOWS
 202 #endif
 203 #if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
 204 #  ifndef WIN32
 205 #    define WIN32
 206 #  endif
 207 #endif
 208 #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
 209 #  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
 210 #    ifndef SYS16BIT
 211 #      define SYS16BIT
 212 #    endif
 213 #  endif
 214 #endif
 215
 216 /*
 217  * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
 218  * than 64k bytes at a time (needed on systems with 16-bit int).
 219  */
 220 #ifdef SYS16BIT
 221 #  define MAXSEG_64K
 222 #endif
 223 #ifdef MSDOS
 224 #  define UNALIGNED_OK
 225 #endif
 226
 227 #ifdef __STDC_VERSION__
 228 #  ifndef STDC
 229 #    define STDC
 230 #  endif
 231 #  if __STDC_VERSION__ >= 199901L
 232 #    ifndef STDC99
 233 #      define STDC99
 234 #    endif
 235 #  endif
 236 #endif
 237 #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
 238 #  define STDC
 239 #endif
 240 #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
 241 #  define STDC
 242 #endif
 243 #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
 244 #  define STDC
 245 #endif
 246 #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
 247 #  define STDC
 248 #endif
 249
 250 #if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
 251 #  define STDC
 252 #endif
 253
 254 #ifndef STDC
 255 #  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
 256 #    define const       /* note: need a more gentle solution here */
 257 #  endif
 258 #endif
 259
 260 /* Some Mac compilers merge all .h files incorrectly: */
 261 #if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
 262 #  define NO_DUMMY_DECL
 263 #endif
 264
 265 /* Maximum value for memLevel in deflateInit2 */
 266 #ifndef MAX_MEM_LEVEL
 267 #  ifdef MAXSEG_64K
 268 #    define MAX_MEM_LEVEL 8
 269 #  else
 270 #    define MAX_MEM_LEVEL 9
 271 #  endif
 272 #endif
 273
 274 /* Maximum value for windowBits in deflateInit2 and inflateInit2.
 275  * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
 276  * created by gzip. (Files created by minigzip can still be extracted by
 277  * gzip.)
 278  */
 279 #ifndef MAX_WBITS
 280 #  define MAX_WBITS   15 /* 32K LZ77 window */
 281 #endif
 282
 283 /* The memory requirements for deflate are (in bytes):
 284             (1 << (windowBits+2)) +  (1 << (memLevel+9))
 285  that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
 286  plus a few kilobytes for small objects. For example, if you want to reduce
 287  the default memory requirements from 256K to 128K, compile with
 288      make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
 289  Of course this will generally degrade compression (there's no free lunch).
 290
 291    The memory requirements for inflate are (in bytes) 1 << windowBits
 292  that is, 32K for windowBits=15 (default value) plus a few kilobytes
 293  for small objects.
 294 */
 295
 296                         /* Type declarations */
 297
 298 #ifndef OF /* function prototypes */
 299 #  ifdef STDC
 300 #    define OF(args)  args
 301 #  else
 302 #    define OF(args)  ()
 303 #  endif
 304 #endif
 305
 306 /* The following definitions for FAR are needed only for MSDOS mixed
 307  * model programming (small or medium model with some far allocations).
 308  * This was tested only with MSC; for other MSDOS compilers you may have
 309  * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
 310  * just define FAR to be empty.
 311  */
 312 #ifdef SYS16BIT
 313 #  if defined(M_I86SM) || defined(M_I86MM)
 314      /* MSC small or medium model */
 315 #    define SMALL_MEDIUM
 316 #    ifdef _MSC_VER
 317 #      define FAR _far
 318 #    else
 319 #      define FAR far
 320 #    endif
 321 #  endif
 322 #  if (defined(__SMALL__) || defined(__MEDIUM__))
 323      /* Turbo C small or medium model */
 324 #    define SMALL_MEDIUM
 325 #    ifdef __BORLANDC__
 326 #      define FAR _far
 327 #    else
 328 #      define FAR far
 329 #    endif
 330 #  endif
 331 #endif
 332
 333 #if defined(WINDOWS) || defined(WIN32)
 334    /* If building or using zlib as a DLL, define ZLIB_DLL.
 335     * This is not mandatory, but it offers a little performance increase.
 336     */
 337 #  ifdef ZLIB_DLL
 338 #    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
 339 #      ifdef ZLIB_INTERNAL
 340 #        define ZEXTERN extern __declspec(dllexport)
 341 #      else
 342 #        define ZEXTERN extern __declspec(dllimport)
 343 #      endif
 344 #    endif
 345 #  endif  /* ZLIB_DLL */
 346    /* If building or using zlib with the WINAPI/WINAPIV calling convention,
 347     * define ZLIB_WINAPI.
 348     * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
 349     */
 350 #  ifdef ZLIB_WINAPI
 351 #    ifdef FAR
 352 #      undef FAR
 353 #    endif
 354 #    include <windows.h>
 355      /* No need for _export, use ZLIB.DEF instead. */
 356      /* For complete Windows compatibility, use WINAPI, not __stdcall. */
 357 #    define ZEXPORT WINAPI
 358 #    ifdef WIN32
 359 #      define ZEXPORTVA WINAPIV
 360 #    else
 361 #      define ZEXPORTVA FAR CDECL
 362 #    endif
 363 #  endif
 364 #endif
 365
 366 #if defined (__BEOS__)
 367 #  ifdef ZLIB_DLL
 368 #    ifdef ZLIB_INTERNAL
 369 #      define ZEXPORT   __declspec(dllexport)
 370 #      define ZEXPORTVA __declspec(dllexport)
 371 #    else
 372 #      define ZEXPORT   __declspec(dllimport)
 373 #      define ZEXPORTVA __declspec(dllimport)
 374 #    endif
 375 #  endif
 376 #endif
 377
 378 #ifndef ZEXTERN
 379 #  define ZEXTERN extern
 380 #endif
 381 #ifndef ZEXPORT
 382 #  define ZEXPORT
 383 #endif
 384 #ifndef ZEXPORTVA
 385 #  define ZEXPORTVA
 386 #endif
 387
 388 #ifndef FAR
 389 #  define FAR
 390 #endif
 391
 392 #if !defined(__MACTYPES__)
 393 typedef unsigned char  Byte;  /* 8 bits */
 394 #endif
 395 typedef unsigned int   uInt;  /* 16 bits or more */
 396 typedef unsigned long  uLong; /* 32 bits or more */
 397
 398 #ifdef SMALL_MEDIUM
 399    /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
 400 #  define Bytef Byte FAR
 401 #else
 402    typedef Byte  FAR Bytef;
 403 #endif
 404 typedef char  FAR charf;
 405 typedef int   FAR intf;
 406 typedef uInt  FAR uIntf;
 407 typedef uLong FAR uLongf;
 408
 409 #ifdef STDC
 410    typedef void const *voidpc;
 411    typedef void FAR   *voidpf;
 412    typedef void       *voidp;
 413 #else
 414    typedef Byte const *voidpc;
 415    typedef Byte FAR   *voidpf;
 416    typedef Byte       *voidp;
 417 #endif
 418
 419 #if HAVE_UNISTD_H
 420 #  include <sys/types.h> /* for off_t */
 421 #  include <unistd.h>    /* for SEEK_* and off_t */
 422 #  ifdef VMS
 423 #    include <unixio.h>   /* for off_t */
 424 #  endif
 425 #  define z_off_t off_t
 426 #endif
 427 #ifndef SEEK_SET
 428 #  define SEEK_SET        0       /* Seek from beginning of file.  */
 429 #  define SEEK_CUR        1       /* Seek from current position.  */
 430 #  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
 431 #endif
 432 #ifndef z_off_t
 433 #  define z_off_t long
 434 #endif
 435
 436 #if defined(__OS400__)
 437 #  define NO_vsnprintf
 438 #endif
 439
 440 #if defined(__MVS__)
 441 #  define NO_vsnprintf
 442 #endif
 443
 444 /* MVS linker does not support external names larger than 8 bytes */
 445 #if defined(__MVS__)
 446 #   pragma map(deflateInit_,"DEIN")
 447 #   pragma map(deflateInit2_,"DEIN2")
 448 #   pragma map(deflateEnd,"DEEND")
 449 #   pragma map(deflateBound,"DEBND")
 450 #   pragma map(inflateInit_,"ININ")
 451 #   pragma map(inflateInit2_,"ININ2")
 452 #   pragma map(inflateEnd,"INEND")
 453 #   pragma map(inflateSync,"INSY")
 454 #   pragma map(inflateSetDictionary,"INSEDI")
 455 #   pragma map(compressBound,"CMBND")
 456 #   pragma map(inflate_table,"INTABL")
 457 #   pragma map(inflate_fast,"INFA")
 458 #   pragma map(inflate_copyright,"INCOPY")
 459 #endif
 460
 461 #endif /* _ZCONF_H */
 462
 463 #define ZLIB_VERSION "1.2.3"
 464 #define ZLIB_VERNUM 0x1230
 465
 466 /*
 467      The 'zlib' compression library provides in-memory compression and
 468   decompression functions, including integrity checks of the uncompressed
 469   data.  This version of the library supports only one compression method
 470   (deflation) but other algorithms will be added later and will have the same
 471   stream interface.
 472
 473      Compression can be done in a single step if the buffers are large
 474   enough (for example if an input file is mmap'ed), or can be done by
 475   repeated calls of the compression function.  In the latter case, the
 476   application must provide more input and/or consume the output
 477   (providing more output space) before each call.
 478
 479      The compressed data format used by default by the in-memory functions is
 480   the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
 481   around a deflate stream, which is itself documented in RFC 1951.
 482
 483      The library also supports reading and writing files in gzip (.gz) format
 484   with an interface similar to that of stdio using the functions that start
 485   with "gz".  The gzip format is different from the zlib format.  gzip is a
 486   gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
 487
 488      This library can optionally read and write gzip streams in memory as well.
 489
 490      The zlib format was designed to be compact and fast for use in memory
 491   and on communications channels.  The gzip format was designed for single-
 492   file compression on file systems, has a larger header than zlib to maintain
 493   directory information, and uses a different, slower check method than zlib.
 494
 495      The library does not install any signal handler. The decoder checks
 496   the consistency of the compressed data, so the library should never
 497   crash even in case of corrupted input.
 498 */
 499
 500 typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
 501 typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
 502
 503 struct internal_state;
 504
 505 typedef struct z_stream_s {
 506     Bytef    *next_in;  /* next input byte */
 507     uInt     avail_in;  /* number of bytes available at next_in */
 508     uLong    total_in;  /* total nb of input bytes read so far */
 509
 510     Bytef    *next_out; /* next output byte should be put there */
 511     uInt     avail_out; /* remaining free space at next_out */
 512     uLong    total_out; /* total nb of bytes output so far */
 513
 514     char     *msg;      /* last error message, NULL if no error */
 515     struct internal_state FAR *state; /* not visible by applications */
 516
 517     alloc_func zalloc;  /* used to allocate the internal state */
 518     free_func  zfree;   /* used to free the internal state */
 519     voidpf     opaque;  /* private data object passed to zalloc and zfree */
 520
 521     int     data_type;  /* best guess about the data type: binary or text */
 522     uLong   adler;      /* adler32 value of the uncompressed data */
 523     uLong   reserved;   /* reserved for future use */
 524 } z_stream;
 525
 526 typedef z_stream FAR *z_streamp;
 527
 528                         /* constants */
 529
 530 #define Z_NO_FLUSH      0
 531 #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
 532 #define Z_SYNC_FLUSH    2
 533 #define Z_FULL_FLUSH    3
 534 #define Z_FINISH        4
 535 #define Z_BLOCK         5
 536 /* Allowed flush values; see deflate() and inflate() below for details */
 537
 538 #define Z_OK            0
 539 #define Z_STREAM_END    1
 540 #define Z_NEED_DICT     2
 541 #define Z_ERRNO        (-1)
 542 #define Z_STREAM_ERROR (-2)
 543 #define Z_DATA_ERROR   (-3)
 544 #define Z_MEM_ERROR    (-4)
 545 #define Z_BUF_ERROR    (-5)
 546 #define Z_VERSION_ERROR (-6)
 547 /* Return codes for the compression/decompression functions. Negative
 548  * values are errors, positive values are used for special but normal events.
 549  */
 550
 551 #define Z_NO_COMPRESSION         0
 552 #define Z_BEST_SPEED             1
 553 #define Z_BEST_COMPRESSION       9
 554 #define Z_DEFAULT_COMPRESSION  (-1)
 555 /* compression levels */
 556
 557 #define Z_FILTERED            1
 558 #define Z_HUFFMAN_ONLY        2
 559 #define Z_RLE                 3
 560 #define Z_FIXED               4
 561 #define Z_DEFAULT_STRATEGY    0
 562 /* compression strategy; see deflateInit2() below for details */
 563
 564 #define Z_BINARY   0
 565 #define Z_TEXT     1
 566 #define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
 567 #define Z_UNKNOWN  2
 568 /* Possible values of the data_type field (though see inflate()) */
 569
 570 #define Z_DEFLATED   8
 571 /* The deflate compression method (the only one supported in this version) */
 572
 573 #define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
 574
 575 #define inflateInit2(strm, windowBits) \
 576         inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
 577
 578 #endif /* _ZLIB_H */
 579
 580 #ifndef _ZUTIL_H
 581 #define _ZUTIL_H        1
 582
 583 #if !_PACKAGE_ast && !defined(STDC)
 584 #if defined(__STDC__)
 585 #  include <stddef.h>
 586 #endif
 587 #  include <string.h>
 588 #  include <stdlib.h>
 589 #endif
 590
 591 #ifndef local
 592 #  define local static
 593 #endif
 594 /* compile with -Dlocal if your debugger can't find static symbols */
 595
 596 typedef unsigned char  uch;
 597 typedef uch FAR uchf;
 598 typedef unsigned short ush;
 599 typedef ush FAR ushf;
 600 typedef unsigned long  ulg;
 601
 602         /* common constants */
 603
 604 #ifndef DEF_WBITS
 605 #  define DEF_WBITS MAX_WBITS
 606 #endif
 607 /* default windowBits for decompression. MAX_WBITS is for compression only */
 608
 609 #if MAX_MEM_LEVEL >= 8
 610 #  define DEF_MEM_LEVEL 8
 611 #else
 612 #  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
 613 #endif
 614 /* default memLevel */
 615
 616 #define STORED_BLOCK 0
 617 #define STATIC_TREES 1
 618 #define DYN_TREES    2
 619 /* The three kinds of block type */
 620
 621 #define MIN_MATCH  3
 622 #define MAX_MATCH  258
 623 /* The minimum and maximum match lengths */
 624
 625 #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
 626
 627         /* target dependencies */
 628
 629 #if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
 630 #  define OS_CODE  0x00
 631 #  if defined(__TURBOC__) || defined(__BORLANDC__)
 632 #    if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
 633        /* Allow compilation with ANSI keywords only enabled */
 634        void _Cdecl farfree( void *block );
 635        void *_Cdecl farmalloc( unsigned long nbytes );
 636 #    else
 637 #      include <alloc.h>
 638 #    endif
 639 #  else /* MSC or DJGPP */
 640 #    include <malloc.h>
 641 #  endif
 642 #endif
 643
 644 #ifdef AMIGA
 645 #  define OS_CODE  0x01
 646 #endif
 647
 648 #if defined(VAXC) || defined(VMS)
 649 #  define OS_CODE  0x02
 650 #  define F_OPEN(name, mode) \
 651      fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
 652 #endif
 653
 654 #if defined(ATARI) || defined(atarist)
 655 #  define OS_CODE  0x05
 656 #endif
 657
 658 #ifdef OS2
 659 #  define OS_CODE  0x06
 660 #  ifdef M_I86
 661      #include <malloc.h>
 662 #  endif
 663 #endif
 664
 665 #if defined(MACOS) || defined(TARGET_OS_MAC)
 666 #  define OS_CODE  0x07
 667 #  if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
 668 #    include <unix.h> /* for fdopen */
 669 #  else
 670 #    ifndef fdopen
 671 #      define fdopen(fd,mode) NULL /* No fdopen() */
 672 #    endif
 673 #  endif
 674 #endif
 675
 676 #ifdef TOPS20
 677 #  define OS_CODE  0x0a
 678 #endif
 679
 680 #ifdef WIN32
 681 #  ifndef __CYGWIN__  /* Cygwin is Unix, not Win32 */
 682 #    define OS_CODE  0x0b
 683 #  endif
 684 #endif
 685
 686 #ifdef __50SERIES /* Prime/PRIMOS */
 687 #  define OS_CODE  0x0f
 688 #endif
 689
 690 #if defined(_BEOS_) || defined(RISCOS)
 691 #  define fdopen(fd,mode) NULL /* No fdopen() */
 692 #endif
 693
 694 #if (defined(_MSC_VER) && (_MSC_VER > 600))
 695 #  if defined(_WIN32_WCE)
 696 #    define fdopen(fd,mode) NULL /* No fdopen() */
 697 #    ifndef _PTRDIFF_T_DEFINED
 698        typedef int ptrdiff_t;
 699 #      define _PTRDIFF_T_DEFINED
 700 #    endif
 701 #  else
 702 #    define fdopen(fd,type)  _fdopen(fd,type)
 703 #  endif
 704 #endif
 705
 706         /* common defaults */
 707
 708 #ifndef OS_CODE
 709 #  define OS_CODE  0x03  /* assume Unix */
 710 #endif
 711
 712 #ifndef F_OPEN
 713 #  define F_OPEN(name, mode) fopen((name), (mode))
 714 #endif
 715
 716          /* functions */
 717
 718 #if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
 719 #  ifndef HAVE_VSNPRINTF
 720 #    define HAVE_VSNPRINTF
 721 #  endif
 722 #endif
 723 #if defined(__CYGWIN__)
 724 #  ifndef HAVE_VSNPRINTF
 725 #    define HAVE_VSNPRINTF
 726 #  endif
 727 #endif
 728 #ifndef HAVE_VSNPRINTF
 729 #  ifdef MSDOS
 730      /* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
 731         but for now we just assume it doesn't. */
 732 #    define NO_vsnprintf
 733 #  endif
 734 #  ifdef __TURBOC__
 735 #    define NO_vsnprintf
 736 #  endif
 737 #  ifdef WIN32
 738      /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
 739 #    if !defined(vsnprintf) && !defined(NO_vsnprintf)
 740 #      define vsnprintf _vsnprintf
 741 #    endif
 742 #  endif
 743 #  ifdef __SASC
 744 #    define NO_vsnprintf
 745 #  endif
 746 #endif
 747 #ifdef VMS
 748 #  define NO_vsnprintf
 749 #endif
 750
 751 #if defined(pyr)
 752 #  define NO_MEMCPY
 753 #endif
 754 #if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
 755  /* Use our own functions for small and medium model with MSC <= 5.0.
 756   * You may have to use the same strategy for Borland C (untested).
 757   * The __SC__ check is for Symantec.
 758   */
 759 #  define NO_MEMCPY
 760 #endif
 761 #if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
 762 #  define HAVE_MEMCPY
 763 #endif
 764 #ifdef HAVE_MEMCPY
 765 #  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
 766 #    define zmemcpy _fmemcpy
 767 #    define zmemcmp _fmemcmp
 768 #    define zmemzero(dest, len) _fmemset(dest, 0, len)
 769 #  else
 770 #    define zmemcpy memcpy
 771 #    define zmemcmp memcmp
 772 #    define zmemzero(dest, len) memset(dest, 0, len)
 773 #  endif
 774 #else
 775    extern void zmemcpy  OF((Bytef* dest, const Bytef* source, uInt len));
 776    extern int  zmemcmp  OF((const Bytef* s1, const Bytef* s2, uInt len));
 777    extern void zmemzero OF((Bytef* dest, uInt len));
 778 #endif
 779
 780 /* Diagnostic functions */
 781 #ifdef Z_DEBUG
 782 #  include <stdio.h>
 783    extern int z_verbose;
 784    extern void z_error    OF((char *m));
 785 #  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
 786 #  define Trace(x) {if (z_verbose>=0) fprintf x ;}
 787 #  define Tracev(x) {if (z_verbose>0) fprintf x ;}
 788 #  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
 789 #  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
 790 #  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
 791 #else
 792 #  define Assert(cond,msg)
 793 #  define Trace(x)
 794 #  define Tracev(x)
 795 #  define Tracevv(x)
 796 #  define Tracec(c,x)
 797 #  define Tracecv(c,x)
 798 #endif
 799
 800
 801 voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
 802 void   zcfree  OF((voidpf opaque, voidpf ptr));
 803
 804 #define ZALLOC(strm, items, size) \
 805            (*((strm)->zalloc))((strm)->opaque, (items), (size))
 806 #define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
 807 #define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
 808 #endif /* _ZUTIL_H */
 809
 810 #ifndef _ZUTIL_C
 811 #define _ZUTIL_C
 812
 813 #if 0 && !_PACKAGE_ast && !defined(STDC)
 814 extern void exit OF((int));
 815 #endif
 816
 817 #ifndef HAVE_MEMCPY
 818
 819 void zmemcpy(dest, source, len)
 820     Bytef* dest;
 821     const Bytef* source;
 822     uInt  len;
 823 {
 824     if (len == 0) return;
 825     do {
 826         *dest++ = *source++; /* ??? to be unrolled */
 827     } while (--len != 0);
 828 }
 829
 830 int zmemcmp(s1, s2, len)
 831     const Bytef* s1;
 832     const Bytef* s2;
 833     uInt  len;
 834 {
 835     uInt j;
 836
 837     for (j = 0; j < len; j++) {
 838         if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
 839     }
 840     return 0;
 841 }
 842
 843 void zmemzero(dest, len)
 844     Bytef* dest;
 845     uInt  len;
 846 {
 847     if (len == 0) return;
 848     do {
 849         *dest++ = 0;  /* ??? to be unrolled */
 850     } while (--len != 0);
 851 }
 852 #endif
 853
 854
 855 #ifdef SYS16BIT
 856
 857 #ifdef __TURBOC__
 858 /* Turbo C in 16-bit mode */
 859
 860 #  define MY_ZCALLOC
 861
 862 /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
 863  * and farmalloc(64K) returns a pointer with an offset of 8, so we
 864  * must fix the pointer. Warning: the pointer must be put back to its
 865  * original form in order to free it, use zcfree().
 866  */
 867
 868 #define MAX_PTR 10
 869 /* 10*64K = 640K */
 870
 871 local int next_ptr = 0;
 872
 873 typedef struct ptr_table_s {
 874     voidpf org_ptr;
 875     voidpf new_ptr;
 876 } ptr_table;
 877
 878 local ptr_table table[MAX_PTR];
 879 /* This table is used to remember the original form of pointers
 880  * to large buffers (64K). Such pointers are normalized with a zero offset.
 881  * Since MSDOS is not a preemptive multitasking OS, this table is not
 882  * protected from concurrent access. This hack doesn't work anyway on
 883  * a protected system like OS/2. Use Microsoft C instead.
 884  */
 885
 886 voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
 887 {
 888     voidpf buf = opaque; /* just to make some compilers happy */
 889     ulg bsize = (ulg)items*size;
 890
 891     /* If we allocate less than 65520 bytes, we assume that farmalloc
 892      * will return a usable pointer which doesn't have to be normalized.
 893      */
 894     if (bsize < 65520L) {
 895         buf = farmalloc(bsize);
 896         if (*(ush*)&buf != 0) return buf;
 897     } else {
 898         buf = farmalloc(bsize + 16L);
 899     }
 900     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
 901     table[next_ptr].org_ptr = buf;
 902
 903     /* Normalize the pointer to seg:0 */
 904     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
 905     *(ush*)&buf = 0;
 906     table[next_ptr++].new_ptr = buf;
 907     return buf;
 908 }
 909
 910 void  zcfree (voidpf opaque, voidpf ptr)
 911 {
 912     int n;
 913     if (*(ush*)&ptr != 0) { /* object < 64K */
 914         farfree(ptr);
 915         return;
 916     }
 917     /* Find the original pointer */
 918     for (n = 0; n < next_ptr; n++) {
 919         if (ptr != table[n].new_ptr) continue;
 920
 921         farfree(table[n].org_ptr);
 922         while (++n < next_ptr) {
 923             table[n-1] = table[n];
 924         }
 925         next_ptr--;
 926         return;
 927     }
 928     ptr = opaque; /* just to make some compilers happy */
 929     Assert(0, "zcfree: ptr not found");
 930 }
 931
 932 #endif /* __TURBOC__ */
 933
 934
 935 #ifdef M_I86
 936 /* Microsoft C in 16-bit mode */
 937
 938 #  define MY_ZCALLOC
 939
 940 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
 941 #  define _halloc  halloc
 942 #  define _hfree   hfree
 943 #endif
 944
 945 voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
 946 {
 947     if (opaque) opaque = 0; /* to make compiler happy */
 948     return _halloc((long)items, size);
 949 }
 950
 951 void  zcfree (voidpf opaque, voidpf ptr)
 952 {
 953     if (opaque) opaque = 0; /* to make compiler happy */
 954     _hfree(ptr);
 955 }
 956
 957 #endif /* M_I86 */
 958
 959 #endif /* SYS16BIT */
 960
 961
 962 #ifndef MY_ZCALLOC /* Any system without a special alloc function */
 963
 964 #if 0 && !_PACKAGE_ast
 965 #ifndef STDC
 966 extern voidp  malloc OF((uInt size));
 967 extern voidp  calloc OF((uInt items, uInt size));
 968 extern void   free   OF((voidpf ptr));
 969 #endif
 970 #endif
 971
 972 voidpf zcalloc (opaque, items, size)
 973     voidpf opaque;
 974     unsigned items;
 975     unsigned size;
 976 {
 977     if (opaque) items += size - size; /* make compiler happy */
 978     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
 979                               (voidpf)calloc(items, size);
 980 }
 981
 982 void  zcfree (opaque, ptr)
 983     voidpf opaque;
 984     voidpf ptr;
 985 {
 986     free(ptr);
 987     if (opaque) return; /* make compiler happy */
 988 }
 989
 990 #endif /* MY_ZCALLOC */
 991
 992 #endif /* _ZUTIL_C */
 993
 994 #ifndef _CRC32_H
 995 #define _CRC32_H        1
 996
 997 /* crc32.h -- tables for rapid CRC calculation
 998  * Generated automatically by crc32.c
 999  */
1000
1001 #ifndef TBLS
1002 #define TBLS    1
1003 #endif
1004
1005 local const unsigned long FAR crc_table[TBLS][256] =
1006 {
1007   {
1008     0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1009     0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1010     0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1011     0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1012     0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1013     0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1014     0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1015     0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1016     0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1017     0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1018     0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1019     0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1020     0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1021     0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1022     0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1023     0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1024     0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1025     0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1026     0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1027     0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1028     0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1029     0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1030     0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1031     0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1032     0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1033     0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1034     0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1035     0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1036     0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1037     0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1038     0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1039     0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1040     0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1041     0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1042     0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1043     0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1044     0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1045     0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1046     0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1047     0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1048     0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1049     0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1050     0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1051     0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1052     0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1053     0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1054     0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1055     0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1056     0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1057     0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1058     0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1059     0x2d02ef8d
1060   },
1061 };
1062
1063 #endif /* _CRC32_H */
1064
1065 #ifndef _CRC32_C
1066 #define _CRC32_C        1
1067
1068 /* ========================================================================= */
1069 #define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
1070 #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
1071
1072 /* ========================================================================= */
1073 unsigned long ZEXPORT crc32(crc, buf, len)
1074     unsigned long crc;
1075     const unsigned char FAR *buf;
1076     unsigned len;
1077 {
1078     if (buf == Z_NULL) return 0;
1079
1080 #ifdef DYNAMIC_CRC_TABLE
1081     if (crc_table_empty)
1082         make_crc_table();
1083 #endif /* DYNAMIC_CRC_TABLE */
1084
1085 #ifdef BYFOUR
1086     if (sizeof(void *) == sizeof(ptrdiff_t)) {
1087         u4 endian;
1088
1089         endian = 1;
1090         if (*((unsigned char *)(&endian)))
1091             return crc32_little(crc, buf, len);
1092         else
1093             return crc32_big(crc, buf, len);
1094     }
1095 #endif /* BYFOUR */
1096     crc = crc ^ 0xffffffff;
1097     while (len >= 8) {
1098         DO8;
1099         len -= 8;
1100     }
1101     if (len) do {
1102         DO1;
1103     } while (--len);
1104     return crc ^ 0xffffffff;
1105 }
1106
1107 #undef  DO1
1108 #undef  DO8
1109
1110 #endif /* _CRC32_C */
1111
1112 #ifndef _ADLER32_C
1113 #define _ADLER32_C      1
1114
1115 #define BASE 65521    /* largest prime smaller than 65536 */
1116 #define NMAX 5552
1117 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
1118
1119 #define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
1120 #define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
1121 #define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
1122 #define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
1123 #define DO16(buf)   DO8(buf,0); DO8(buf,8);
1124
1125 /* use NO_DIVIDE if your processor does not do division in hardware */
1126 #ifdef NO_DIVIDE
1127 #  define MOD(a) \
1128     do { \
1129         if (a >= (BASE << 16)) a -= (BASE << 16); \
1130         if (a >= (BASE << 15)) a -= (BASE << 15); \
1131         if (a >= (BASE << 14)) a -= (BASE << 14); \
1132         if (a >= (BASE << 13)) a -= (BASE << 13); \
1133         if (a >= (BASE << 12)) a -= (BASE << 12); \
1134         if (a >= (BASE << 11)) a -= (BASE << 11); \
1135         if (a >= (BASE << 10)) a -= (BASE << 10); \
1136         if (a >= (BASE << 9)) a -= (BASE << 9); \
1137         if (a >= (BASE << 8)) a -= (BASE << 8); \
1138         if (a >= (BASE << 7)) a -= (BASE << 7); \
1139         if (a >= (BASE << 6)) a -= (BASE << 6); \
1140         if (a >= (BASE << 5)) a -= (BASE << 5); \
1141         if (a >= (BASE << 4)) a -= (BASE << 4); \
1142         if (a >= (BASE << 3)) a -= (BASE << 3); \
1143         if (a >= (BASE << 2)) a -= (BASE << 2); \
1144         if (a >= (BASE << 1)) a -= (BASE << 1); \
1145         if (a >= BASE) a -= BASE; \
1146     } while (0)
1147 #  define MOD4(a) \
1148     do { \
1149         if (a >= (BASE << 4)) a -= (BASE << 4); \
1150         if (a >= (BASE << 3)) a -= (BASE << 3); \
1151         if (a >= (BASE << 2)) a -= (BASE << 2); \
1152         if (a >= (BASE << 1)) a -= (BASE << 1); \
1153         if (a >= BASE) a -= BASE; \
1154     } while (0)
1155 #else
1156 #  define MOD(a) a %= BASE
1157 #  define MOD4(a) a %= BASE
1158 #endif
1159
1160 /* ========================================================================= */
1161 uLong ZEXPORT adler32(adler, buf, len)
1162     uLong adler;
1163     const Bytef *buf;
1164     uInt len;
1165 {
1166     unsigned long sum2;
1167     unsigned n;
1168
1169     /* split Adler-32 into component sums */
1170     sum2 = (adler >> 16) & 0xffff;
1171     adler &= 0xffff;
1172
1173     /* in case user likes doing a byte at a time, keep it fast */
1174     if (len == 1) {
1175         adler += buf[0];
1176         if (adler >= BASE)
1177             adler -= BASE;
1178         sum2 += adler;
1179         if (sum2 >= BASE)
1180             sum2 -= BASE;
1181         return adler | (sum2 << 16);
1182     }
1183
1184     /* initial Adler-32 value (deferred check for len == 1 speed) */
1185     if (buf == Z_NULL)
1186         return 1L;
1187
1188     /* in case short lengths are provided, keep it somewhat fast */
1189     if (len < 16) {
1190         while (len--) {
1191             adler += *buf++;
1192             sum2 += adler;
1193         }
1194         if (adler >= BASE)
1195             adler -= BASE;
1196         MOD4(sum2);             /* only added so many BASE's */
1197         return adler | (sum2 << 16);
1198     }
1199
1200     /* do length NMAX blocks -- requires just one modulo operation */
1201     while (len >= NMAX) {
1202         len -= NMAX;
1203         n = NMAX / 16;          /* NMAX is divisible by 16 */
1204         do {
1205             DO16(buf);          /* 16 sums unrolled */
1206             buf += 16;
1207         } while (--n);
1208         MOD(adler);
1209         MOD(sum2);
1210     }
1211
1212     /* do remaining bytes (less than NMAX, still just one modulo) */
1213     if (len) {                  /* avoid modulos if none remaining */
1214         while (len >= 16) {
1215             len -= 16;
1216             DO16(buf);
1217             buf += 16;
1218         }
1219         while (len--) {
1220             adler += *buf++;
1221             sum2 += adler;
1222         }
1223         MOD(adler);
1224         MOD(sum2);
1225     }
1226
1227     /* return recombined sums */
1228     return adler | (sum2 << 16);
1229 }
1230
1231 #endif /* _ADLER32_C */
1232
1233 #ifndef _DEFLATE_H
1234 #define _DEFLATE_H      1
1235
1236 /* ===========================================================================
1237  * Internal compression state.
1238  */
1239
1240 #define LENGTH_CODES 29
1241 /* number of length codes, not counting the special END_BLOCK code */
1242
1243 #define LITERALS  256
1244 /* number of literal bytes 0..255 */
1245
1246 #define L_CODES (LITERALS+1+LENGTH_CODES)
1247 /* number of Literal or Length codes, including the END_BLOCK code */
1248
1249 #define D_CODES   30
1250 /* number of distance codes */
1251
1252 #define BL_CODES  19
1253 /* number of codes used to transfer the bit lengths */
1254
1255 #define HEAP_SIZE (2*L_CODES+1)
1256 /* maximum heap size */
1257
1258 #define MAX_BITS 15
1259 /* All codes must not exceed MAX_BITS bits */
1260
1261 #define INIT_STATE    42
1262 #define EXTRA_STATE   69
1263 #define NAME_STATE    73
1264 #define COMMENT_STATE 91
1265 #define HCRC_STATE   103
1266 #define BUSY_STATE   113
1267 #define FINISH_STATE 666
1268 /* Stream status */
1269
1270
1271 /* Data structure describing a single value and its code string. */
1272 typedef struct ct_data_s {
1273     union {
1274         ush  freq;       /* frequency count */
1275         ush  code;       /* bit string */
1276     } fc;
1277     union {
1278         ush  dad;        /* father node in Huffman tree */
1279         ush  len;        /* length of bit string */
1280     } dl;
1281 } FAR ct_data;
1282
1283 #define Freq fc.freq
1284 #define Code fc.code
1285 #define Dad  dl.dad
1286 #define Len  dl.len
1287
1288 typedef struct static_tree_desc_s  static_tree_desc;
1289
1290 typedef struct tree_desc_s {
1291     ct_data *dyn_tree;           /* the dynamic tree */
1292     int     max_code;            /* largest code with non zero frequency */
1293     static_tree_desc *stat_desc; /* the corresponding static tree */
1294 } FAR tree_desc;
1295
1296 typedef ush Pos;
1297 typedef Pos FAR Posf;
1298 typedef unsigned IPos;
1299
1300 /* A Pos is an index in the character window. We use short instead of int to
1301  * save space in the various tables. IPos is used only for parameter passing.
1302  */
1303
1304 typedef struct internal_state {
1305     z_streamp strm;      /* pointer back to this zlib stream */
1306     int   status;        /* as the name implies */
1307     Bytef *pending_buf;  /* output still pending */
1308     ulg   pending_buf_size; /* size of pending_buf */
1309     Bytef *pending_out;  /* next pending byte to output to the stream */
1310     uInt   pending;      /* nb of bytes in the pending buffer */
1311     int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
1312     gz_headerp  gzhead;  /* gzip header information to write */
1313     uInt   gzindex;      /* where in extra, name, or comment */
1314     Byte  method;        /* STORED (for zip only) or DEFLATED */
1315     int   last_flush;    /* value of flush param for previous deflate call */
1316
1317                 /* used by deflate.c: */
1318
1319     uInt  w_size;        /* LZ77 window size (32K by default) */
1320     uInt  w_bits;        /* log2(w_size)  (8..16) */
1321     uInt  w_mask;        /* w_size - 1 */
1322
1323     Bytef *window;
1324     /* Sliding window. Input bytes are read into the second half of the window,
1325      * and move to the first half later to keep a dictionary of at least wSize
1326      * bytes. With this organization, matches are limited to a distance of
1327      * wSize-MAX_MATCH bytes, but this ensures that IO is always
1328      * performed with a length multiple of the block size. Also, it limits
1329      * the window size to 64K, which is quite useful on MSDOS.
1330      * To do: use the user input buffer as sliding window.
1331      */
1332
1333     ulg window_size;
1334     /* Actual size of window: 2*wSize, except when the user input buffer
1335      * is directly used as sliding window.
1336      */
1337
1338     Posf *prev;
1339     /* Link to older string with same hash index. To limit the size of this
1340      * array to 64K, this link is maintained only for the last 32K strings.
1341      * An index in this array is thus a window index modulo 32K.
1342      */
1343
1344     Posf *head; /* Heads of the hash chains or NIL. */
1345
1346     uInt  ins_h;          /* hash index of string to be inserted */
1347     uInt  hash_size;      /* number of elements in hash table */
1348     uInt  hash_bits;      /* log2(hash_size) */
1349     uInt  hash_mask;      /* hash_size-1 */
1350
1351     uInt  hash_shift;
1352     /* Number of bits by which ins_h must be shifted at each input
1353      * step. It must be such that after MIN_MATCH steps, the oldest
1354      * byte no longer takes part in the hash key, that is:
1355      *   hash_shift * MIN_MATCH >= hash_bits
1356      */
1357
1358     long block_start;
1359     /* Window position at the beginning of the current output block. Gets
1360      * negative when the window is moved backwards.
1361      */
1362
1363     uInt match_length;           /* length of best match */
1364     IPos prev_match;             /* previous match */
1365     int match_available;         /* set if previous match exists */
1366     uInt strstart;               /* start of string to insert */
1367     uInt match_start;            /* start of matching string */
1368     uInt lookahead;              /* number of valid bytes ahead in window */
1369
1370     uInt prev_length;
1371     /* Length of the best match at previous step. Matches not greater than this
1372      * are discarded. This is used in the lazy match evaluation.
1373      */
1374
1375     uInt max_chain_length;
1376     /* To speed up deflation, hash chains are never searched beyond this
1377      * length.  A higher limit improves compression ratio but degrades the
1378      * speed.
1379      */
1380
1381     uInt max_lazy_match;
1382     /* Attempt to find a better match only when the current match is strictly
1383      * smaller than this value. This mechanism is used only for compression
1384      * levels >= 4.
1385      */
1386 #   define max_insert_length  max_lazy_match
1387     /* Insert new strings in the hash table only if the match length is not
1388      * greater than this length. This saves time but degrades compression.
1389      * max_insert_length is used only for compression levels <= 3.
1390      */
1391
1392     int level;    /* compression level (1..9) */
1393     int strategy; /* favor or force Huffman coding*/
1394
1395     uInt good_match;
1396     /* Use a faster search when the previous match is longer than this */
1397
1398     int nice_match; /* Stop searching when current match exceeds this */
1399
1400                 /* used by trees.c: */
1401     /* Didn't use ct_data typedef below to supress compiler warning */
1402     struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
1403     struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
1404     struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
1405
1406     struct tree_desc_s l_desc;               /* desc. for literal tree */
1407     struct tree_desc_s d_desc;               /* desc. for distance tree */
1408     struct tree_desc_s bl_desc;              /* desc. for bit length tree */
1409
1410     ush bl_count[MAX_BITS+1];
1411     /* number of codes at each bit length for an optimal tree */
1412
1413     int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
1414     int heap_len;               /* number of elements in the heap */
1415     int heap_max;               /* element of largest frequency */
1416     /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
1417      * The same heap array is used to build all trees.
1418      */
1419
1420     uch depth[2*L_CODES+1];
1421     /* Depth of each subtree used as tie breaker for trees of equal frequency
1422      */
1423
1424     uchf *l_buf;          /* buffer for literals or lengths */
1425
1426     uInt  lit_bufsize;
1427     /* Size of match buffer for literals/lengths.  There are 4 reasons for
1428      * limiting lit_bufsize to 64K:
1429      *   - frequencies can be kept in 16 bit counters
1430      *   - if compression is not successful for the first block, all input
1431      *     data is still in the window so we can still emit a stored block even
1432      *     when input comes from standard input.  (This can also be done for
1433      *     all blocks if lit_bufsize is not greater than 32K.)
1434      *   - if compression is not successful for a file smaller than 64K, we can
1435      *     even emit a stored file instead of a stored block (saving 5 bytes).
1436      *     This is applicable only for zip (not gzip or zlib).
1437      *   - creating new Huffman trees less frequently may not provide fast
1438      *     adaptation to changes in the input data statistics. (Take for
1439      *     example a binary file with poorly compressible code followed by
1440      *     a highly compressible string table.) Smaller buffer sizes give
1441      *     fast adaptation but have of course the overhead of transmitting
1442      *     trees more frequently.
1443      *   - I can't count above 4
1444      */
1445
1446     uInt last_lit;      /* running index in l_buf */
1447
1448     ushf *d_buf;
1449     /* Buffer for distances. To simplify the code, d_buf and l_buf have
1450      * the same number of elements. To use different lengths, an extra flag
1451      * array would be necessary.
1452      */
1453
1454     ulg opt_len;        /* bit length of current block with optimal trees */
1455     ulg static_len;     /* bit length of current block with static trees */
1456     uInt matches;       /* number of string matches in current block */
1457     int last_eob_len;   /* bit length of EOB code for last block */
1458
1459 #ifdef Z_DEBUG
1460     ulg compressed_len; /* total bit length of compressed file mod 2^32 */
1461     ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
1462 #endif
1463
1464     ush bi_buf;
1465     /* Output buffer. bits are inserted starting at the bottom (least
1466      * significant bits).
1467      */
1468     int bi_valid;
1469     /* Number of valid bits in bi_buf.  All bits above the last valid bit
1470      * are always zero.
1471      */
1472
1473 } FAR deflate_state;
1474
1475 /* Output a byte on the stream.
1476  * IN assertion: there is enough room in pending_buf.
1477  */
1478 #define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
1479
1480
1481 #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
1482 /* Minimum amount of lookahead, except at the end of the input file.
1483  * See deflate.c for comments about the MIN_MATCH+1.
1484  */
1485
1486 #define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
1487 /* In order to simplify the code, particularly on 16 bit machines, match
1488  * distances are limited to MAX_DIST instead of WSIZE.
1489  */
1490
1491         /* in trees.c */
1492 void _tr_init         OF((deflate_state *s));
1493 int  _tr_tally        OF((deflate_state *s, unsigned dist, unsigned lc));
1494 void _tr_flush_block  OF((deflate_state *s, charf *buf, ulg stored_len,
1495                           int eof));
1496 void _tr_align        OF((deflate_state *s));
1497 void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
1498                           int eof));
1499
1500 #define d_code(dist) \
1501    ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
1502 /* Mapping from a distance to a distance code. dist is the distance - 1 and
1503  * must not have side effects. _dist_code[256] and _dist_code[257] are never
1504  * used.
1505  */
1506
1507 #ifndef Z_DEBUG
1508 /* Inline versions of _tr_tally for speed: */
1509
1510 #if defined(GEN_TREES_H) || !defined(STDC)
1511   extern uch _length_code[];
1512   extern uch _dist_code[];
1513 #else
1514   extern const uch _length_code[];
1515   extern const uch _dist_code[];
1516 #endif
1517
1518 # define _tr_tally_lit(s, c, flush) \
1519   { uch cc = (c); \
1520     s->d_buf[s->last_lit] = 0; \
1521     s->l_buf[s->last_lit++] = cc; \
1522     s->dyn_ltree[cc].Freq++; \
1523     flush = (s->last_lit == s->lit_bufsize-1); \
1524    }
1525 # define _tr_tally_dist(s, distance, length, flush) \
1526   { uch len = (length); \
1527     ush dist = (distance); \
1528     s->d_buf[s->last_lit] = dist; \
1529     s->l_buf[s->last_lit++] = len; \
1530     dist--; \
1531     s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
1532     s->dyn_dtree[d_code(dist)].Freq++; \
1533     flush = (s->last_lit == s->lit_bufsize-1); \
1534   }
1535 #else
1536 # define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
1537 # define _tr_tally_dist(s, distance, length, flush) \
1538               flush = _tr_tally(s, distance, length)
1539 #endif
1540
1541 #endif /* _DEFLATE_H */
1542
1543 #ifndef _INFTREES_H
1544 #define _INFTREES_H     1
1545
1546 typedef struct {
1547     unsigned char op;           /* operation, extra bits, table bits */
1548     unsigned char bits;         /* bits in this part of the code */
1549     unsigned short val;         /* offset in table or code value */
1550 } code;
1551
1552 /* op values as set by inflate_table():
1553     00000000 - literal
1554     0000tttt - table link, tttt != 0 is the number of table index bits
1555     0001eeee - length or distance, eeee is the number of extra bits
1556     01100000 - end of block
1557     01000000 - invalid code
1558  */
1559
1560 /* Maximum size of dynamic tree.  The maximum found in a long but non-
1561    exhaustive search was 1444 code structures (852 for length/literals
1562    and 592 for distances, the latter actually the result of an
1563    exhaustive search).  The true maximum is not known, but the value
1564    below is more than safe. */
1565 #define ENOUGH 2048
1566 #define MAXD 592
1567
1568 /* Type of code to build for inftable() */
1569 typedef enum {
1570     CODES,
1571     LENS,
1572     DISTS
1573 } codetype;
1574
1575 #endif /* _INFTREES_H */
1576
1577 #ifndef _INFLATE_H
1578 #define _INFLATE_H      1
1579
1580 /* Possible inflate modes between inflate() calls */
1581 typedef enum {
1582     HEAD,       /* i: waiting for magic header */
1583     FLAGS,      /* i: waiting for method and flags (gzip) */
1584     TIME,       /* i: waiting for modification time (gzip) */
1585     OS,         /* i: waiting for extra flags and operating system (gzip) */
1586     EXLEN,      /* i: waiting for extra length (gzip) */
1587     EXTRA,      /* i: waiting for extra bytes (gzip) */
1588     NAME,       /* i: waiting for end of file name (gzip) */
1589     COMMENT,    /* i: waiting for end of comment (gzip) */
1590     HCRC,       /* i: waiting for header crc (gzip) */
1591     DICTID,     /* i: waiting for dictionary check value */
1592     DICT,       /* waiting for inflateSetDictionary() call */
1593         TYPE,       /* i: waiting for type bits, including last-flag bit */
1594         TYPEDO,     /* i: same, but skip check to exit inflate on new block */
1595         STORED,     /* i: waiting for stored size (length and complement) */
1596         COPY,       /* i/o: waiting for input or output to copy stored block */
1597         TABLE,      /* i: waiting for dynamic block table lengths */
1598         LENLENS,    /* i: waiting for code length code lengths */
1599         CODELENS,   /* i: waiting for length/lit and distance code lengths */
1600             LEN,        /* i: waiting for length/lit code */
1601             LENEXT,     /* i: waiting for length extra bits */
1602             DIST,       /* i: waiting for distance code */
1603             DISTEXT,    /* i: waiting for distance extra bits */
1604             MATCH,      /* o: waiting for output space to copy string */
1605             LIT,        /* o: waiting for output space to write literal */
1606     CHECK,      /* i: waiting for 32-bit check value */
1607     LENGTH,     /* i: waiting for 32-bit length (gzip) */
1608     DONE,       /* finished check, done -- remain here until reset */
1609     BAD,        /* got a data error -- remain here until reset */
1610     MEM,        /* got an inflate() memory error -- remain here until reset */
1611     SYNC        /* looking for synchronization bytes to restart inflate() */
1612 } inflate_mode;
1613
1614 /*
1615     State transitions between above modes -
1616
1617     (most modes can go to the BAD or MEM mode -- not shown for clarity)
1618
1619     Process header:
1620         HEAD -> (gzip) or (zlib)
1621         (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
1622         NAME -> COMMENT -> HCRC -> TYPE
1623         (zlib) -> DICTID or TYPE
1624         DICTID -> DICT -> TYPE
1625     Read deflate blocks:
1626             TYPE -> STORED or TABLE or LEN or CHECK
1627             STORED -> COPY -> TYPE
1628             TABLE -> LENLENS -> CODELENS -> LEN
1629     Read deflate codes:
1630                 LEN -> LENEXT or LIT or TYPE
1631                 LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
1632                 LIT -> LEN
1633     Process trailer:
1634         CHECK -> LENGTH -> DONE
1635  */
1636
1637 /* state maintained between inflate() calls.  Approximately 7K bytes. */
1638 struct inflate_state {
1639     inflate_mode mode;          /* current inflate mode */
1640     int last;                   /* true if processing last block */
1641     int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip */
1642     int havedict;               /* true if dictionary provided */
1643     int flags;                  /* gzip header method and flags (0 if zlib) */
1644     unsigned dmax;              /* zlib header max distance (INFLATE_STRICT) */
1645     unsigned long check;        /* protected copy of check value */
1646     unsigned long total;        /* protected copy of output count */
1647     gz_headerp head;            /* where to save gzip header information */
1648         /* sliding window */
1649     unsigned wbits;             /* log base 2 of requested window size */
1650     unsigned wsize;             /* window size or zero if not using window */
1651     unsigned whave;             /* valid bytes in the window */
1652     unsigned write;             /* window write index */
1653     unsigned char FAR *window;  /* allocated sliding window, if needed */
1654         /* bit accumulator */
1655     unsigned long hold;         /* input bit accumulator */
1656     unsigned bits;              /* number of bits in "in" */
1657         /* for string and stored block copying */
1658     unsigned length;            /* literal or length of data to copy */
1659     unsigned offset;            /* distance back to copy string from */
1660         /* for table and code decoding */
1661     unsigned extra;             /* extra bits needed */
1662         /* fixed and dynamic code tables */
1663     code const FAR *lencode;    /* starting table for length/literal codes */
1664     code const FAR *distcode;   /* starting table for distance codes */
1665     unsigned lenbits;           /* index bits for lencode */
1666     unsigned distbits;          /* index bits for distcode */
1667         /* dynamic table building */
1668     unsigned ncode;             /* number of code length code lengths */
1669     unsigned nlen;              /* number of length code lengths */
1670     unsigned ndist;             /* number of distance code lengths */
1671     unsigned have;              /* number of code lengths in lens[] */
1672     code FAR *next;             /* next available space in codes[] */
1673     unsigned short lens[320];   /* temporary storage for code lengths */
1674     unsigned short work[288];   /* work area for code table building */
1675     code codes[ENOUGH];         /* space for code tables */
1676 };
1677 #endif /* _INFLATE_H */
1678
1679 #ifndef _INFTREES_C
1680 #define _INFTREES_C     1
1681
1682 #define MAXBITS 15
1683
1684 const char inflate_copyright[] =
1685    " inflate 1.2.3 Copyright 1995-2005 Mark Adler ";
1686 /*
1687   If you use the zlib library in a product, an acknowledgment is welcome
1688   in the documentation of your product. If for some reason you cannot
1689   include such an acknowledgment, I would appreciate that you keep this
1690   copyright string in the executable of your product.
1691  */
1692
1693 /*
1694    Build a set of tables to decode the provided canonical Huffman code.
1695    The code lengths are lens[0..codes-1].  The result starts at *table,
1696    whose indices are 0..2^bits-1.  work is a writable array of at least
1697    lens shorts, which is used as a work area.  type is the type of code
1698    to be generated, CODES, LENS, or DISTS.  On return, zero is success,
1699    -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
1700    on return points to the next available entry's address.  bits is the
1701    requested root table index bits, and on return it is the actual root
1702    table index bits.  It will differ if the request is greater than the
1703    longest code or if it is less than the shortest code.
1704  */
1705 int inflate_table(type, lens, codes, table, bits, work)
1706 codetype type;
1707 unsigned short FAR *lens;
1708 unsigned codes;
1709 code FAR * FAR *table;
1710 unsigned FAR *bits;
1711 unsigned short FAR *work;
1712 {
1713     unsigned len;               /* a code's length in bits */
1714     unsigned sym;               /* index of code symbols */
1715     unsigned min, max;          /* minimum and maximum code lengths */
1716     unsigned root;              /* number of index bits for root table */
1717     unsigned curr;              /* number of index bits for current table */
1718     unsigned drop;              /* code bits to drop for sub-table */
1719     int left;                   /* number of prefix codes available */
1720     unsigned used;              /* code entries in table used */
1721     unsigned huff;              /* Huffman code */
1722     unsigned incr;              /* for incrementing code, index */
1723     unsigned fill;              /* index for replicating entries */
1724     unsigned low;               /* low bits for current root entry */
1725     unsigned mask;              /* mask for low root bits */
1726     code this;                  /* table entry for duplication */
1727     code FAR *next;             /* next available space in table */
1728     const unsigned short FAR *base;     /* base value table to use */
1729     const unsigned short FAR *extra;    /* extra bits table to use */
1730     int end;                    /* use base and extra for symbol > end */
1731     unsigned short count[MAXBITS+1];    /* number of codes of each length */
1732     unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
1733     static const unsigned short lbase[31] = { /* Length codes 257..285 base */
1734         3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
1735         35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
1736     static const unsigned short lext[31] = { /* Length codes 257..285 extra */
1737         16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
1738         19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
1739     static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
1740         1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
1741         257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
1742         8193, 12289, 16385, 24577, 0, 0};
1743     static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
1744         16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
1745         23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
1746         28, 28, 29, 29, 64, 64};
1747
1748     /*
1749        Process a set of code lengths to create a canonical Huffman code.  The
1750        code lengths are lens[0..codes-1].  Each length corresponds to the
1751        symbols 0..codes-1.  The Huffman code is generated by first sorting the
1752        symbols by length from short to long, and retaining the symbol order
1753        for codes with equal lengths.  Then the code starts with all zero bits
1754        for the first code of the shortest length, and the codes are integer
1755        increments for the same length, and zeros are appended as the length
1756        increases.  For the deflate format, these bits are stored backwards
1757        from their more natural integer increment ordering, and so when the
1758        decoding tables are built in the large loop below, the integer codes
1759        are incremented backwards.
1760
1761        This routine assumes, but does not check, that all of the entries in
1762        lens[] are in the range 0..MAXBITS.  The caller must assure this.
1763        1..MAXBITS is interpreted as that code length.  zero means that that
1764        symbol does not occur in this code.
1765
1766        The codes are sorted by computing a count of codes for each length,
1767        creating from that a table of starting indices for each length in the
1768        sorted table, and then entering the symbols in order in the sorted
1769        table.  The sorted table is work[], with that space being provided by
1770        the caller.
1771
1772        The length counts are used for other purposes as well, i.e. finding
1773        the minimum and maximum length codes, determining if there are any
1774        codes at all, checking for a valid set of lengths, and looking ahead
1775        at length counts to determine sub-table sizes when building the
1776        decoding tables.
1777      */
1778
1779     /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
1780     for (len = 0; len <= MAXBITS; len++)
1781         count[len] = 0;
1782     for (sym = 0; sym < codes; sym++)
1783         count[lens[sym]]++;
1784
1785     /* bound code lengths, force root to be within code lengths */
1786     root = *bits;
1787     for (max = MAXBITS; max >= 1; max--)
1788         if (count[max] != 0) break;
1789     if (root > max) root = max;
1790     if (max == 0) {                     /* no symbols to code at all */
1791         this.op = (unsigned char)64;    /* invalid code marker */
1792         this.bits = (unsigned char)1;
1793         this.val = (unsigned short)0;
1794         *(*table)++ = this;             /* make a table to force an error */
1795         *(*table)++ = this;
1796         *bits = 1;
1797         return 0;     /* no symbols, but wait for decoding to report error */
1798     }
1799     for (min = 1; min <= MAXBITS; min++)
1800         if (count[min] != 0) break;
1801     if (root < min) root = min;
1802
1803     /* check for an over-subscribed or incomplete set of lengths */
1804     left = 1;
1805     for (len = 1; len <= MAXBITS; len++) {
1806         left <<= 1;
1807         left -= count[len];
1808         if (left < 0) return -1;        /* over-subscribed */
1809     }
1810     if (left > 0 && (type == CODES || max != 1))
1811         return -1;                      /* incomplete set */
1812
1813     /* generate offsets into symbol table for each length for sorting */
1814     offs[1] = 0;
1815     for (len = 1; len < MAXBITS; len++)
1816         offs[len + 1] = offs[len] + count[len];
1817
1818     /* sort symbols by length, by symbol order within each length */
1819     for (sym = 0; sym < codes; sym++)
1820         if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
1821
1822     /*
1823        Create and fill in decoding tables.  In this loop, the table being
1824        filled is at next and has curr index bits.  The code being used is huff
1825        with length len.  That code is converted to an index by dropping drop
1826        bits off of the bottom.  For codes where len is less than drop + curr,
1827        those top drop + curr - len bits are incremented through all values to
1828        fill the table with replicated entries.
1829
1830        root is the number of index bits for the root table.  When len exceeds
1831        root, sub-tables are created pointed to by the root entry with an index
1832        of the low root bits of huff.  This is saved in low to check for when a
1833        new sub-table should be started.  drop is zero when the root table is
1834        being filled, and drop is root when sub-tables are being filled.
1835
1836        When a new sub-table is needed, it is necessary to look ahead in the
1837        code lengths to determine what size sub-table is needed.  The length
1838        counts are used for this, and so count[] is decremented as codes are
1839        entered in the tables.
1840
1841        used keeps track of how many table entries have been allocated from the
1842        provided *table space.  It is checked when a LENS table is being made
1843        against the space in *table, ENOUGH, minus the maximum space needed by
1844        the worst case distance code, MAXD.  This should never happen, but the
1845        sufficiency of ENOUGH has not been proven exhaustively, hence the check.
1846        This assumes that when type == LENS, bits == 9.
1847
1848        sym increments through all symbols, and the loop terminates when
1849        all codes of length max, i.e. all codes, have been processed.  This
1850        routine permits incomplete codes, so another loop after this one fills
1851        in the rest of the decoding tables with invalid code markers.
1852      */
1853
1854     /* set up for code type */
1855     switch (type) {
1856     case CODES:
1857         base = extra = work;    /* dummy value--not used */
1858         end = 19;
1859         break;
1860     case LENS:
1861         base = lbase;
1862         base -= 257;
1863         extra = lext;
1864         extra -= 257;
1865         end = 256;
1866         break;
1867     default:            /* DISTS */
1868         base = dbase;
1869         extra = dext;
1870         end = -1;
1871     }
1872
1873     /* initialize state for loop */
1874     huff = 0;                   /* starting code */
1875     sym = 0;                    /* starting code symbol */
1876     len = min;                  /* starting code length */
1877     next = *table;              /* current table to fill in */
1878     curr = root;                /* current table index bits */
1879     drop = 0;                   /* current bits to drop from code for index */
1880     low = (unsigned)(-1);       /* trigger new sub-table when len > root */
1881     used = ((unsigned int)1) << root;          /* use root table entries */
1882     mask = used - 1;            /* mask for comparing low */
1883
1884     /* check available table space */
1885     if (type == LENS && used >= ENOUGH - MAXD)
1886         return 1;
1887
1888     /* process all codes and make table entries */
1889     for (;;) {
1890         /* create table entry */
1891         this.bits = (unsigned char)(len - drop);
1892         if ((int)(work[sym]) < end) {
1893             this.op = (unsigned char)0;
1894             this.val = work[sym];
1895         }
1896         else if ((int)(work[sym]) > end) {
1897             this.op = (unsigned char)(extra[work[sym]]);
1898             this.val = base[work[sym]];
1899         }
1900         else {
1901             this.op = (unsigned char)(32 + 64);         /* end of block */
1902             this.val = 0;
1903         }
1904
1905         /* replicate for those indices with low len bits equal to huff */
1906         incr = ((unsigned int)1) << (len - drop);
1907         fill = ((unsigned int)1) << curr;
1908         min = fill;                 /* save offset to next table */
1909         do {
1910             fill -= incr;
1911             next[(huff >> drop) + fill] = this;
1912         } while (fill != 0);
1913
1914         /* backwards increment the len-bit code huff */
1915         incr = ((unsigned int)1) << (len - 1);
1916         while (huff & incr)
1917             incr >>= 1;
1918         if (incr != 0) {
1919             huff &= incr - 1;
1920             huff += incr;
1921         }
1922         else
1923             huff = 0;
1924
1925         /* go to next symbol, update count, len */
1926         sym++;
1927         if (--(count[len]) == 0) {
1928             if (len == max) break;
1929             len = lens[work[sym]];
1930         }
1931
1932         /* create new sub-table if needed */
1933         if (len > root && (huff & mask) != low) {
1934             /* if first time, transition to sub-tables */
1935             if (drop == 0)
1936                 drop = root;
1937
1938             /* increment past last table */
1939             next += min;            /* here min is 1 << curr */
1940
1941             /* determine length of next table */
1942             curr = len - drop;
1943             left = (int)(1 << curr);
1944             while (curr + drop < max) {
1945                 left -= count[curr + drop];
1946                 if (left <= 0) break;
1947                 curr++;
1948                 left <<= 1;
1949             }
1950
1951             /* check for enough space */
1952             used += ((unsigned int)1) << curr;
1953             if (type == LENS && used >= ENOUGH - MAXD)
1954                 return 1;
1955
1956             /* point entry in root table to sub-table */
1957             low = huff & mask;
1958             (*table)[low].op = (unsigned char)curr;
1959             (*table)[low].bits = (unsigned char)root;
1960             (*table)[low].val = (unsigned short)(next - *table);
1961         }
1962     }
1963
1964     /*
1965        Fill in rest of table for incomplete codes.  This loop is similar to the
1966        loop above in incrementing huff for table indices.  It is assumed that
1967        len is equal to curr + drop, so there is no loop needed to increment
1968        through high index bits.  When the current sub-table is filled, the loop
1969        drops back to the root table to fill in any remaining entries there.
1970      */
1971     this.op = (unsigned char)64;                /* invalid code marker */
1972     this.bits = (unsigned char)(len - drop);
1973     this.val = (unsigned short)0;
1974     while (huff != 0) {
1975         /* when done with sub-table, drop back to root table */
1976         if (drop != 0 && (huff & mask) != low) {
1977             drop = 0;
1978             len = root;
1979             next = *table;
1980             this.bits = (unsigned char)len;
1981         }
1982
1983         /* put invalid code marker in table */
1984         next[huff >> drop] = this;
1985
1986         /* backwards increment the len-bit code huff */
1987         incr = ((unsigned int)1) << (len - 1);
1988         while (huff & incr)
1989             incr >>= 1;
1990         if (incr != 0) {
1991             huff &= incr - 1;
1992             huff += incr;
1993         }
1994         else
1995             huff = 0;
1996     }
1997
1998     /* set return parameters */
1999     *table += used;
2000     *bits = root;
2001     return 0;
2002 }
2003
2004 #endif /* _INFTREES_C */
2005
2006 #ifndef _INFFAST_C
2007 #define _INFFAST_C      1
2008
2009 /* Allow machine dependent optimization for post-increment or pre-increment.
2010    Based on testing to date,
2011    Pre-increment preferred for:
2012    - PowerPC G3 (Adler)
2013    - MIPS R5000 (Randers-Pehrson)
2014    Post-increment preferred for:
2015    - none
2016    No measurable difference:
2017    - Pentium III (Anderson)
2018    - M68060 (Nikl)
2019  */
2020 #undef  OFF             /* (ancient) sunos <locale.h> */
2021 #ifdef POSTINC
2022 #  define OFF 0
2023 #  define PUP(a) *(a)++
2024 #else
2025 #  define OFF 1
2026 #  define PUP(a) *++(a)
2027 #endif
2028
2029 /*
2030    Decode literal, length, and distance codes and write out the resulting
2031    literal and match bytes until either not enough input or output is
2032    available, an end-of-block is encountered, or a data error is encountered.
2033    When large enough input and output buffers are supplied to inflate(), for
2034    example, a 16K input buffer and a 64K output buffer, more than 95% of the
2035    inflate execution time is spent in this routine.
2036
2037    Entry assumptions:
2038
2039         state->mode == LEN
2040         strm->avail_in >= 6
2041         strm->avail_out >= 258
2042         start >= strm->avail_out
2043         state->bits < 8
2044
2045    On return, state->mode is one of:
2046
2047         LEN -- ran out of enough output space or enough available input
2048         TYPE -- reached end of block code, inflate() to interpret next block
2049         BAD -- error in block data
2050
2051    Notes:
2052
2053     - The maximum input bits used by a length/distance pair is 15 bits for the
2054       length code, 5 bits for the length extra, 15 bits for the distance code,
2055       and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
2056       Therefore if strm->avail_in >= 6, then there is enough input to avoid
2057       checking for available input while decoding.
2058
2059     - The maximum bytes that a single length/distance pair can output is 258
2060       bytes, which is the maximum length that can be coded.  inflate_fast()
2061       requires strm->avail_out >= 258 for each loop to avoid checking for
2062       output space.
2063  */
2064 void inflate_fast(strm, start)
2065 z_streamp strm;
2066 unsigned start;         /* inflate()'s starting value for strm->avail_out */
2067 {
2068     struct inflate_state FAR *state;
2069     unsigned char FAR *in;      /* local strm->next_in */
2070     unsigned char FAR *last;    /* while in < last, enough input available */
2071     unsigned char FAR *out;     /* local strm->next_out */
2072     unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
2073     unsigned char FAR *end;     /* while out < end, enough space available */
2074 #ifdef INFLATE_STRICT
2075     unsigned dmax;              /* maximum distance from zlib header */
2076 #endif
2077     unsigned wsize;             /* window size or zero if not using window */
2078     unsigned whave;             /* valid bytes in the window */
2079     unsigned write;             /* window write index */
2080     unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
2081     unsigned long hold;         /* local strm->hold */
2082     unsigned bits;              /* local strm->bits */
2083     code const FAR *lcode;      /* local strm->lencode */
2084     code const FAR *dcode;      /* local strm->distcode */
2085     unsigned lmask;             /* mask for first level of length codes */
2086     unsigned dmask;             /* mask for first level of distance codes */
2087     code this;                  /* retrieved table entry */
2088     unsigned op;                /* code bits, operation, extra bits, or */
2089                                 /*  window position, window bytes to copy */
2090     unsigned len;               /* match length, unused bytes */
2091     unsigned dist;              /* match distance */
2092     unsigned char FAR *from;    /* where to copy match from */
2093
2094     /* copy state to local variables */
2095     state = (struct inflate_state FAR *)strm->state;
2096     in = strm->next_in - OFF;
2097     last = in + (strm->avail_in - 5);
2098     out = strm->next_out - OFF;
2099     beg = out - (start - strm->avail_out);
2100     end = out + (strm->avail_out - 257);
2101 #ifdef INFLATE_STRICT
2102     dmax = state->dmax;
2103 #endif
2104     wsize = state->wsize;
2105     whave = state->whave;
2106     write = state->write;
2107     window = state->window;
2108     hold = state->hold;
2109     bits = state->bits;
2110     lcode = state->lencode;
2111     dcode = state->distcode;
2112     lmask = (((unsigned int)1) << state->lenbits) - 1;
2113     dmask = (((unsigned int)1) << state->distbits) - 1;
2114
2115     /* decode literals and length/distances until end-of-block or not enough
2116        input data or output space */
2117     do {
2118         if (bits < 15) {
2119             hold += (unsigned long)(PUP(in)) << bits;
2120             bits += 8;
2121             hold += (unsigned long)(PUP(in)) << bits;
2122             bits += 8;
2123         }
2124         this = lcode[hold & lmask];
2125       dolen:
2126         op = (unsigned)(this.bits);
2127         hold >>= op;
2128         bits -= op;
2129         op = (unsigned)(this.op);
2130         if (op == 0) {                          /* literal */
2131             Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
2132                     "inflate:         literal '%c'\n" :
2133                     "inflate:         literal 0x%02x\n", this.val));
2134             PUP(out) = (unsigned char)(this.val);
2135         }
2136         else if (op & 16) {                     /* length base */
2137             len = (unsigned)(this.val);
2138             op &= 15;                           /* number of extra bits */
2139             if (op) {
2140                 if (bits < op) {
2141                     hold += (unsigned long)(PUP(in)) << bits;
2142                     bits += 8;
2143                 }
2144                 len += (unsigned)hold & ((((unsigned int)1) << op) - 1);
2145                 hold >>= op;
2146                 bits -= op;
2147             }
2148             Tracevv((stderr, "inflate:         length %u\n", len));
2149             if (bits < 15) {
2150                 hold += (unsigned long)(PUP(in)) << bits;
2151                 bits += 8;
2152                 hold += (unsigned long)(PUP(in)) << bits;
2153                 bits += 8;
2154             }
2155             this = dcode[hold & dmask];
2156           dodist:
2157             op = (unsigned)(this.bits);
2158             hold >>= op;
2159             bits -= op;
2160             op = (unsigned)(this.op);
2161             if (op & 16) {                      /* distance base */
2162                 dist = (unsigned)(this.val);
2163                 op &= 15;                       /* number of extra bits */
2164                 if (bits < op) {
2165                     hold += (unsigned long)(PUP(in)) << bits;
2166                     bits += 8;
2167                     if (bits < op) {
2168                         hold += (unsigned long)(PUP(in)) << bits;
2169                         bits += 8;
2170                     }
2171                 }
2172                 dist += (unsigned)hold & ((((unsigned int)1) << op) - 1);
2173 #ifdef INFLATE_STRICT
2174                 if (dist > dmax) {
2175                     strm->msg = (char *)"invalid distance too far back";
2176                     state->mode = BAD;
2177                     break;
2178                 }
2179 #endif
2180                 hold >>= op;
2181                 bits -= op;
2182                 Tracevv((stderr, "inflate:         distance %u\n", dist));
2183                 op = (unsigned)(out - beg);     /* max distance in output */
2184                 if (dist > op) {                /* see if copy from window */
2185                     op = dist - op;             /* distance back in window */
2186                     if (op > whave) {
2187                         strm->msg = (char *)"invalid distance too far back";
2188                         state->mode = BAD;
2189                         break;
2190                     }
2191                     from = window - OFF;
2192                     if (write == 0) {           /* very common case */
2193                         from += wsize - op;
2194                         if (op < len) {         /* some from window */
2195                             len -= op;
2196                             do {
2197                                 PUP(out) = PUP(from);
2198                             } while (--op);
2199                             from = out - dist;  /* rest from output */
2200                         }
2201                     }
2202                     else if (write < op) {      /* wrap around window */
2203                         from += wsize + write - op;
2204                         op -= write;
2205                         if (op < len) {         /* some from end of window */
2206                             len -= op;
2207                             do {
2208                                 PUP(out) = PUP(from);
2209                             } while (--op);
2210                             from = window - OFF;
2211                             if (write < len) {  /* some from start of window */
2212                                 op = write;
2213                                 len -= op;
2214                                 do {
2215                                     PUP(out) = PUP(from);
2216                                 } while (--op);
2217                                 from = out - dist;      /* rest from output */
2218                             }
2219                         }
2220                     }
2221                     else {                      /* contiguous in window */
2222                         from += write - op;
2223                         if (op < len) {         /* some from window */
2224                             len -= op;
2225                             do {
2226                                 PUP(out) = PUP(from);
2227                             } while (--op);
2228                             from = out - dist;  /* rest from output */
2229                         }
2230                     }
2231                     while (len > 2) {
2232                         PUP(out) = PUP(from);
2233                         PUP(out) = PUP(from);
2234                         PUP(out) = PUP(from);
2235                         len -= 3;
2236                     }
2237                     if (len) {
2238                         PUP(out) = PUP(from);
2239                         if (len > 1)
2240                             PUP(out) = PUP(from);
2241                     }
2242                 }
2243                 else {
2244                     from = out - dist;          /* copy direct from output */
2245                     do {                        /* minimum length is three */
2246                         PUP(out) = PUP(from);
2247                         PUP(out) = PUP(from);
2248                         PUP(out) = PUP(from);
2249                         len -= 3;
2250                     } while (len > 2);
2251                     if (len) {
2252                         PUP(out) = PUP(from);
2253                         if (len > 1)
2254                             PUP(out) = PUP(from);
2255                     }
2256                 }
2257             }
2258             else if ((op & 64) == 0) {          /* 2nd level distance code */
2259                 this = dcode[this.val + (hold & ((((unsigned int)1) << op) - 1))];
2260                 goto dodist;
2261             }
2262             else {
2263                 strm->msg = (char *)"invalid distance code";
2264                 state->mode = BAD;
2265                 break;
2266             }
2267         }
2268         else if ((op & 64) == 0) {              /* 2nd level length code */
2269             this = lcode[this.val + (hold & ((((unsigned int)1) << op) - 1))];
2270             goto dolen;
2271         }
2272         else if (op & 32) {                     /* end-of-block */
2273             Tracevv((stderr, "inflate:         end of block\n"));
2274             state->mode = TYPE;
2275             break;
2276         }
2277         else {
2278             strm->msg = (char *)"invalid literal/length code";
2279             state->mode = BAD;
2280             break;
2281         }
2282     } while (in < last && out < end);
2283
2284     /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
2285     len = bits >> 3;
2286     in -= len;
2287     bits -= len << 3;
2288     hold &= (((unsigned int)1) << bits) - 1;
2289
2290     /* update state and return */
2291     strm->next_in = in + OFF;
2292     strm->next_out = out + OFF;
2293     strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
2294     strm->avail_out = (unsigned)(out < end ?
2295                                  257 + (end - out) : 257 - (out - end));
2296     state->hold = hold;
2297     state->bits = bits;
2298     return;
2299 }
2300
2301 /*
2302    inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
2303    - Using bit fields for code structure
2304    - Different op definition to avoid & for extra bits (do & for table bits)
2305    - Three separate decoding do-loops for direct, window, and write == 0
2306    - Special case for distance > 1 copies to do overlapped load and store copy
2307    - Explicit branch predictions (based on measured branch probabilities)
2308    - Deferring match copy and interspersed it with decoding subsequent codes
2309    - Swapping literal/length else
2310    - Swapping window/direct else
2311    - Larger unrolled copy loops (three is about right)
2312    - Moving len -= 3 statement into middle of loop
2313  */
2314
2315 #endif /* _INFFAST_C */
2316
2317 #ifndef _INFLATE_C
2318 #define _INFLATE_C      1
2319
2320 /* function prototypes */
2321 local void fixedtables OF((struct inflate_state FAR *state));
2322 local int updatewindow OF((z_streamp strm, unsigned out));
2323 #ifdef BUILDFIXED
2324    void makefixed OF((void));
2325 #endif
2326 local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
2327                               unsigned len));
2328
2329 int ZEXPORT inflateReset(strm)
2330 z_streamp strm;
2331 {
2332     struct inflate_state FAR *state;
2333
2334     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
2335     state = (struct inflate_state FAR *)strm->state;
2336     strm->total_in = strm->total_out = state->total = 0;
2337     strm->msg = Z_NULL;
2338     strm->adler = 1;        /* to support ill-conceived Java test suite */
2339     state->mode = HEAD;
2340     state->last = 0;
2341     state->havedict = 0;
2342     state->dmax = 32768;
2343     state->head = Z_NULL;
2344     state->wsize = 0;
2345     state->whave = 0;
2346     state->write = 0;
2347     state->hold = 0;
2348     state->bits = 0;
2349     state->lencode = state->distcode = state->next = state->codes;
2350     Tracev((stderr, "inflate: reset\n"));
2351     return Z_OK;
2352 }
2353
2354 int ZEXPORT inflatePrime(strm, bits, value)
2355 z_streamp strm;
2356 int bits;
2357 int value;
2358 {
2359     struct inflate_state FAR *state;
2360
2361     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
2362     state = (struct inflate_state FAR *)strm->state;
2363     if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
2364     value &= (1L << bits) - 1;
2365     state->hold += value << state->bits;
2366     state->bits += bits;
2367     return Z_OK;
2368 }
2369
2370 int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
2371 z_streamp strm;
2372 int windowBits;
2373 const char *version;
2374 int stream_size;
2375 {
2376     struct inflate_state FAR *state;
2377
2378     if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
2379         stream_size != (int)(sizeof(z_stream)))
2380         return Z_VERSION_ERROR;
2381     if (strm == Z_NULL) return Z_STREAM_ERROR;
2382     strm->msg = Z_NULL;                 /* in case we return an error */
2383     if (strm->zalloc == (alloc_func)0) {
2384         strm->zalloc = zcalloc;
2385         strm->opaque = (voidpf)0;
2386     }
2387     if (strm->zfree == (free_func)0) strm->zfree = zcfree;
2388     state = (struct inflate_state FAR *)
2389             ZALLOC(strm, 1, sizeof(struct inflate_state));
2390     if (state == Z_NULL) return Z_MEM_ERROR;
2391     Tracev((stderr, "inflate: allocated\n"));
2392     strm->state = (struct internal_state FAR *)state;
2393     if (windowBits < 0) {
2394         state->wrap = 0;
2395         windowBits = -windowBits;
2396     }
2397     else {
2398         state->wrap = (windowBits >> 4) + 1;
2399 #ifdef GUNZIP
2400         if (windowBits < 48) windowBits &= 15;
2401 #endif
2402     }
2403     if (windowBits < 8 || windowBits > 15) {
2404         ZFREE(strm, state);
2405         strm->state = Z_NULL;
2406         return Z_STREAM_ERROR;
2407     }
2408     state->wbits = (unsigned)windowBits;
2409     state->window = Z_NULL;
2410     return inflateReset(strm);
2411 }
2412
2413 int ZEXPORT inflateInit_(strm, version, stream_size)
2414 z_streamp strm;
2415 const char *version;
2416 int stream_size;
2417 {
2418     return inflateInit2_(strm, DEF_WBITS, version, stream_size);
2419 }
2420
2421 /*
2422    Return state with length and distance decoding tables and index sizes set to
2423    fixed code decoding.  Normally this returns fixed tables from inffixed.h.
2424    If BUILDFIXED is defined, then instead this routine builds the tables the
2425    first time it's called, and returns those tables the first time and
2426    thereafter.  This reduces the size of the code by about 2K bytes, in
2427    exchange for a little execution time.  However, BUILDFIXED should not be
2428    used for threaded applications, since the rewriting of the tables and virgin
2429    may not be thread-safe.
2430  */
2431 local void fixedtables(state)
2432 struct inflate_state FAR *state;
2433 {
2434 #ifndef _INFFIXED_H
2435 #define _INFFIXED_H     1
2436     static const code lenfix[512] = {
2437         {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
2438         {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
2439         {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
2440         {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
2441         {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
2442         {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
2443         {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
2444         {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
2445         {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
2446         {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
2447         {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
2448         {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
2449         {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
2450         {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
2451         {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
2452         {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
2453         {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
2454         {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
2455         {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
2456         {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
2457         {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
2458         {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
2459         {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
2460         {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
2461         {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
2462         {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
2463         {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
2464         {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
2465         {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
2466         {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
2467         {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
2468         {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
2469         {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
2470         {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
2471         {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
2472         {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
2473         {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
2474         {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
2475         {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
2476         {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
2477         {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
2478         {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
2479         {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
2480         {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
2481         {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
2482         {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
2483         {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
2484         {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
2485         {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
2486         {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
2487         {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
2488         {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
2489         {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
2490         {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
2491         {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
2492         {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
2493         {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
2494         {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
2495         {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
2496         {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
2497         {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
2498         {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
2499         {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
2500         {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
2501         {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
2502         {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
2503         {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
2504         {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
2505         {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
2506         {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
2507         {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
2508         {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
2509         {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
2510         {0,9,255}
2511     };
2512
2513     static const code distfix[32] = {
2514         {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
2515         {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
2516         {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
2517         {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
2518         {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
2519         {22,5,193},{64,5,0}
2520     };
2521 #endif /* _INFFIXED_H */
2522     state->lencode = lenfix;
2523     state->lenbits = 9;
2524     state->distcode = distfix;
2525     state->distbits = 5;
2526 }
2527
2528 /*
2529    Update the window with the last wsize (normally 32K) bytes written before
2530    returning.  If window does not exist yet, create it.  This is only called
2531    when a window is already in use, or when output has been written during this
2532    inflate call, but the end of the deflate stream has not been reached yet.
2533    It is also called to create a window for dictionary data when a dictionary
2534    is loaded.
2535
2536    Providing output buffers larger than 32K to inflate() should provide a speed
2537    advantage, since only the last 32K of output is copied to the sliding window
2538    upon return from inflate(), and since all distances after the first 32K of
2539    output will fall in the output data, making match copies simpler and faster.
2540    The advantage may be dependent on the size of the processor's data caches.
2541  */
2542 local int updatewindow(strm, out)
2543 z_streamp strm;
2544 unsigned out;
2545 {
2546     struct inflate_state FAR *state;
2547     unsigned copy, dist;
2548
2549     state = (struct inflate_state FAR *)strm->state;
2550
2551     /* if it hasn't been done already, allocate space for the window */
2552     if (state->window == Z_NULL) {
2553         state->window = (unsigned char FAR *)
2554                         ZALLOC(strm, ((unsigned int)1) << state->wbits,
2555                                sizeof(unsigned char));
2556         if (state->window == Z_NULL) return 1;
2557     }
2558
2559     /* if window not in use yet, initialize */
2560     if (state->wsize == 0) {
2561         state->wsize = ((unsigned int)1) << state->wbits;
2562         state->write = 0;
2563         state->whave = 0;
2564     }
2565
2566     /* copy state->wsize or less output bytes into the circular window */
2567     copy = out - strm->avail_out;
2568     if (copy >= state->wsize) {
2569         zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
2570         state->write = 0;
2571         state->whave = state->wsize;
2572     }
2573     else {
2574         dist = state->wsize - state->write;
2575         if (dist > copy) dist = copy;
2576         zmemcpy(state->window + state->write, strm->next_out - copy, dist);
2577         copy -= dist;
2578         if (copy) {
2579             zmemcpy(state->window, strm->next_out - copy, copy);
2580             state->write = copy;
2581             state->whave = state->wsize;
2582         }
2583         else {
2584             state->write += dist;
2585             if (state->write == state->wsize) state->write = 0;
2586             if (state->whave < state->wsize) state->whave += dist;
2587         }
2588     }
2589     return 0;
2590 }
2591
2592 /* Macros for inflate(): */
2593
2594 /* check function to use adler32() for zlib or crc32() for gzip */
2595 #ifdef GUNZIP
2596 #  define UPDATE(check, buf, len) \
2597     (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
2598 #else
2599 #  define UPDATE(check, buf, len) adler32(check, buf, len)
2600 #endif
2601
2602 /* check macros for header crc */
2603 #ifdef GUNZIP
2604 #  define CRC2(check, word) \
2605     do { \
2606         hbuf[0] = (unsigned char)(word); \
2607         hbuf[1] = (unsigned char)((word) >> 8); \
2608         check = crc32(check, hbuf, 2); \
2609     } while (0)
2610
2611 #  define CRC4(check, word) \
2612     do { \
2613         hbuf[0] = (unsigned char)(word); \
2614         hbuf[1] = (unsigned char)((word) >> 8); \
2615         hbuf[2] = (unsigned char)((word) >> 16); \
2616         hbuf[3] = (unsigned char)((word) >> 24); \
2617         check = crc32(check, hbuf, 4); \
2618     } while (0)
2619 #endif
2620
2621 /* Load registers with state in inflate() for speed */
2622 #define LOAD() \
2623     do { \
2624         put = strm->next_out; \
2625         left = strm->avail_out; \
2626         next = strm->next_in; \
2627         have = strm->avail_in; \
2628         hold = state->hold; \
2629         bits = state->bits; \
2630     } while (0)
2631
2632 /* Restore state from registers in inflate() */
2633 #define RESTORE() \
2634     do { \
2635         strm->next_out = put; \
2636         strm->avail_out = left; \
2637         strm->next_in = next; \
2638         strm->avail_in = have; \
2639         state->hold = hold; \
2640         state->bits = bits; \
2641     } while (0)
2642
2643 /* Clear the input bit accumulator */
2644 #define INITBITS() \
2645     do { \
2646         hold = 0; \
2647         bits = 0; \
2648     } while (0)
2649
2650 /* Get a byte of input into the bit accumulator, or return from inflate()
2651    if there is no input available. */
2652 #define PULLBYTE() \
2653     do { \
2654         if (have == 0) goto inf_leave; \
2655         have--; \
2656         hold += (unsigned long)(*next++) << bits; \
2657         bits += 8; \
2658     } while (0)
2659
2660 /* Assure that there are at least n bits in the bit accumulator.  If there is
2661    not enough available input to do that, then return from inflate(). */
2662 #define NEEDBITS(n) \
2663     do { \
2664         while (bits < (unsigned)(n)) \
2665             PULLBYTE(); \
2666     } while (0)
2667
2668 /* Return the low n bits of the bit accumulator (n < 16) */
2669 #define BITS(n) \
2670     ((unsigned)hold & ((((unsigned int)1) << (n)) - 1))
2671
2672 /* Remove n bits from the bit accumulator */
2673 #define DROPBITS(n) \
2674     do { \
2675         hold >>= (n); \
2676         bits -= (unsigned)(n); \
2677     } while (0)
2678
2679 /* Remove zero to seven bits as needed to go to a byte boundary */
2680 #define BYTEBITS() \
2681     do { \
2682         hold >>= bits & 7; \
2683         bits -= bits & 7; \
2684     } while (0)
2685
2686 /* Reverse the bytes in a 32-bit value */
2687 #define REVERSE(q) \
2688     ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
2689      (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
2690
2691 /*
2692    inflate() uses a state machine to process as much input data and generate as
2693    much output data as possible before returning.  The state machine is
2694    structured roughly as follows:
2695
2696     for (;;) switch (state) {
2697     ...
2698     case STATEn:
2699         if (not enough input data or output space to make progress)
2700             return;
2701         ... make progress ...
2702         state = STATEm;
2703         break;
2704     ...
2705     }
2706
2707    so when inflate() is called again, the same case is attempted again, and
2708    if the appropriate resources are provided, the machine proceeds to the
2709    next state.  The NEEDBITS() macro is usually the way the state evaluates
2710    whether it can proceed or should return.  NEEDBITS() does the return if
2711    the requested bits are not available.  The typical use of the BITS macros
2712    is:
2713
2714         NEEDBITS(n);
2715         ... do something with BITS(n) ...
2716         DROPBITS(n);
2717
2718    where NEEDBITS(n) either returns from inflate() if there isn't enough
2719    input left to load n bits into the accumulator, or it continues.  BITS(n)
2720    gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
2721    the low n bits off the accumulator.  INITBITS() clears the accumulator
2722    and sets the number of available bits to zero.  BYTEBITS() discards just
2723    enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
2724    and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
2725
2726    NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
2727    if there is no input available.  The decoding of variable length codes uses
2728    PULLBYTE() directly in order to pull just enough bytes to decode the next
2729    code, and no more.
2730
2731    Some states loop until they get enough input, making sure that enough
2732    state information is maintained to continue the loop where it left off
2733    if NEEDBITS() returns in the loop.  For example, want, need, and keep
2734    would all have to actually be part of the saved state in case NEEDBITS()
2735    returns:
2736
2737     case STATEw:
2738         while (want < need) {
2739             NEEDBITS(n);
2740             keep[want++] = BITS(n);
2741             DROPBITS(n);
2742         }
2743         state = STATEx;
2744     case STATEx:
2745
2746    As shown above, if the next state is also the next case, then the break
2747    is omitted.
2748
2749    A state may also return if there is not enough output space available to
2750    complete that state.  Those states are copying stored data, writing a
2751    literal byte, and copying a matching string.
2752
2753    When returning, a "goto inf_leave" is used to update the total counters,
2754    update the check value, and determine whether any progress has been made
2755    during that inflate() call in order to return the proper return code.
2756    Progress is defined as a change in either strm->avail_in or strm->avail_out.
2757    When there is a window, goto inf_leave will update the window with the last
2758    output written.  If a goto inf_leave occurs in the middle of decompression
2759    and there is no window currently, goto inf_leave will create one and copy
2760    output to the window for the next call of inflate().
2761
2762    In this implementation, the flush parameter of inflate() only affects the
2763    return code (per zlib.h).  inflate() always writes as much as possible to
2764    strm->next_out, given the space available and the provided input--the effect
2765    documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
2766    the allocation of and copying into a sliding window until necessary, which
2767    provides the effect documented in zlib.h for Z_FINISH when the entire input
2768    stream available.  So the only thing the flush parameter actually does is:
2769    when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
2770    will return Z_BUF_ERROR if it has not reached the end of the stream.
2771  */
2772
2773 int ZEXPORT inflate(strm, flush)
2774 z_streamp strm;
2775 int flush;
2776 {
2777     struct inflate_state FAR *state;
2778     unsigned char FAR *next;    /* next input */
2779     unsigned char FAR *put;     /* next output */
2780     unsigned have, left;        /* available input and output */
2781     unsigned long hold;         /* bit buffer */
2782     unsigned bits;              /* bits in bit buffer */
2783     unsigned in, out;           /* save starting available input and output */
2784     unsigned copy;              /* number of stored or match bytes to copy */
2785     unsigned char FAR *from;    /* where to copy match bytes from */
2786     code this;                  /* current decoding table entry */
2787     code last;                  /* parent table entry */
2788     unsigned len;               /* length to copy for repeats, bits to drop */
2789     int ret;                    /* return code */
2790 #ifdef GUNZIP
2791     unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
2792 #endif
2793     static const unsigned short order[19] = /* permutation of code lengths */
2794         {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
2795
2796     if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
2797         (strm->next_in == Z_NULL && strm->avail_in != 0))
2798         return Z_STREAM_ERROR;
2799
2800     state = (struct inflate_state FAR *)strm->state;
2801     if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
2802     LOAD();
2803     in = have;
2804     out = left;
2805     ret = Z_OK;
2806     for (;;)
2807         switch (state->mode) {
2808         case HEAD:
2809             if (state->wrap == 0) {
2810                 state->mode = TYPEDO;
2811                 break;
2812             }
2813             NEEDBITS(16);
2814 #ifdef GUNZIP
2815             if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
2816                 state->check = crc32(0L, Z_NULL, 0);
2817                 CRC2(state->check, hold);
2818                 INITBITS();
2819                 state->mode = FLAGS;
2820                 break;
2821             }
2822             state->flags = 0;           /* expect zlib header */
2823             if (state->head != Z_NULL)
2824                 state->head->done = -1;
2825             if (!(state->wrap & 1) ||   /* check if zlib header allowed */
2826 #else
2827             if (
2828 #endif
2829                 ((BITS(8) << 8) + (hold >> 8)) % 31) {
2830                 strm->msg = (char *)"incorrect header check";
2831                 state->mode = BAD;
2832                 break;
2833             }
2834             if (BITS(4) != Z_DEFLATED) {
2835                 strm->msg = (char *)"unknown compression method";
2836                 state->mode = BAD;
2837                 break;
2838             }
2839             DROPBITS(4);
2840             len = BITS(4) + 8;
2841             if (len > state->wbits) {
2842                 strm->msg = (char *)"invalid window size";
2843                 state->mode = BAD;
2844                 break;
2845             }
2846             state->dmax = ((unsigned int)1) << len;
2847             Tracev((stderr, "inflate:   zlib header ok\n"));
2848             strm->adler = state->check = adler32(0L, Z_NULL, 0);
2849             state->mode = hold & 0x200 ? DICTID : TYPE;
2850             INITBITS();
2851             break;
2852 #ifdef GUNZIP
2853         case FLAGS:
2854             NEEDBITS(16);
2855             state->flags = (int)(hold);
2856             if ((state->flags & 0xff) != Z_DEFLATED) {
2857                 strm->msg = (char *)"unknown compression method";
2858                 state->mode = BAD;
2859                 break;
2860             }
2861             if (state->flags & 0xe000) {
2862                 strm->msg = (char *)"unknown header flags set";
2863                 state->mode = BAD;
2864                 break;
2865             }
2866             if (state->head != Z_NULL)
2867                 state->head->text = (int)((hold >> 8) & 1);
2868             if (state->flags & 0x0200) CRC2(state->check, hold);
2869             INITBITS();
2870             state->mode = TIME;
2871         case TIME:
2872             NEEDBITS(32);
2873             if (state->head != Z_NULL)
2874                 state->head->time = hold;
2875             if (state->flags & 0x0200) CRC4(state->check, hold);
2876             INITBITS();
2877             state->mode = OS;
2878         case OS:
2879             NEEDBITS(16);
2880             if (state->head != Z_NULL) {
2881                 state->head->xflags = (int)(hold & 0xff);
2882                 state->head->os = (int)(hold >> 8);
2883             }
2884             if (state->flags & 0x0200) CRC2(state->check, hold);
2885             INITBITS();
2886             state->mode = EXLEN;
2887         case EXLEN:
2888             if (state->flags & 0x0400) {
2889                 NEEDBITS(16);
2890                 state->length = (unsigned)(hold);
2891                 if (state->head != Z_NULL)
2892                     state->head->extra_len = (unsigned)hold;
2893                 if (state->flags & 0x0200) CRC2(state->check, hold);
2894                 INITBITS();
2895             }
2896             else if (state->head != Z_NULL)
2897                 state->head->extra = Z_NULL;
2898             state->mode = EXTRA;
2899         case EXTRA:
2900             if (state->flags & 0x0400) {
2901                 copy = state->length;
2902                 if (copy > have) copy = have;
2903                 if (copy) {
2904                     if (state->head != Z_NULL &&
2905                         state->head->extra != Z_NULL) {
2906                         len = state->head->extra_len - state->length;
2907                         zmemcpy(state->head->extra + len, next,
2908                                 len + copy > state->head->extra_max ?
2909                                 state->head->extra_max - len : copy);
2910                     }
2911                     if (state->flags & 0x0200)
2912                         state->check = crc32(state->check, next, copy);
2913                     have -= copy;
2914                     next += copy;
2915                     state->length -= copy;
2916                 }
2917                 if (state->length) goto inf_leave;
2918             }
2919             state->length = 0;
2920             state->mode = NAME;
2921         case NAME:
2922             if (state->flags & 0x0800) {
2923                 if (have == 0) goto inf_leave;
2924                 copy = 0;
2925                 do {
2926                     len = (unsigned)(next[copy++]);
2927                     if (state->head != Z_NULL &&
2928                             state->head->name != Z_NULL &&
2929                             state->length < state->head->name_max)
2930                         state->head->name[state->length++] = len;
2931                 } while (len && copy < have);
2932                 if (state->flags & 0x0200)
2933                     state->check = crc32(state->check, next, copy);
2934                 have -= copy;
2935                 next += copy;
2936                 if (len) goto inf_leave;
2937             }
2938             else if (state->head != Z_NULL)
2939                 state->head->name = Z_NULL;
2940             state->length = 0;
2941             state->mode = COMMENT;
2942         case COMMENT:
2943             if (state->flags & 0x1000) {
2944                 if (have == 0) goto inf_leave;
2945                 copy = 0;
2946                 do {
2947                     len = (unsigned)(next[copy++]);
2948                     if (state->head != Z_NULL &&
2949                             state->head->comment != Z_NULL &&
2950                             state->length < state->head->comm_max)
2951                         state->head->comment[state->length++] = len;
2952                 } while (len && copy < have);
2953                 if (state->flags & 0x0200)
2954                     state->check = crc32(state->check, next, copy);
2955                 have -= copy;
2956                 next += copy;
2957                 if (len) goto inf_leave;
2958             }
2959             else if (state->head != Z_NULL)
2960                 state->head->comment = Z_NULL;
2961             state->mode = HCRC;
2962         case HCRC:
2963             if (state->flags & 0x0200) {
2964                 NEEDBITS(16);
2965                 if (hold != (state->check & 0xffff)) {
2966                     strm->msg = (char *)"header crc mismatch";
2967                     state->mode = BAD;
2968                     break;
2969                 }
2970                 INITBITS();
2971             }
2972             if (state->head != Z_NULL) {
2973                 state->head->hcrc = (int)((state->flags >> 9) & 1);
2974                 state->head->done = 1;
2975             }
2976             strm->adler = state->check = crc32(0L, Z_NULL, 0);
2977             state->mode = TYPE;
2978             break;
2979 #endif
2980         case DICTID:
2981             NEEDBITS(32);
2982             strm->adler = state->check = REVERSE(hold);
2983             INITBITS();
2984             state->mode = DICT;
2985         case DICT:
2986             if (state->havedict == 0) {
2987                 RESTORE();
2988                 return Z_NEED_DICT;
2989             }
2990             strm->adler = state->check = adler32(0L, Z_NULL, 0);
2991             state->mode = TYPE;
2992         case TYPE:
2993             if (flush == Z_BLOCK) goto inf_leave;
2994         case TYPEDO:
2995             if (state->last) {
2996                 BYTEBITS();
2997                 state->mode = CHECK;
2998                 break;
2999             }
3000             NEEDBITS(3);
3001             state->last = BITS(1);
3002             DROPBITS(1);
3003             switch (BITS(2)) {
3004             case 0:                             /* stored block */
3005                 Tracev((stderr, "inflate:     stored block%s\n",
3006                         state->last ? " (last)" : ""));
3007                 state->mode = STORED;
3008                 break;
3009             case 1:                             /* fixed block */
3010                 fixedtables(state);
3011                 Tracev((stderr, "inflate:     fixed codes block%s\n",
3012                         state->last ? " (last)" : ""));
3013                 state->mode = LEN;              /* decode codes */
3014                 break;
3015             case 2:                             /* dynamic block */
3016                 Tracev((stderr, "inflate:     dynamic codes block%s\n",
3017                         state->last ? " (last)" : ""));
3018                 state->mode = TABLE;
3019                 break;
3020             case 3:
3021                 strm->msg = (char *)"invalid block type";
3022                 state->mode = BAD;
3023             }
3024             DROPBITS(2);
3025             break;
3026         case STORED:
3027             BYTEBITS();                         /* go to byte boundary */
3028             NEEDBITS(32);
3029             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
3030                 strm->msg = (char *)"invalid stored block lengths";
3031                 state->mode = BAD;
3032                 break;
3033             }
3034             state->length = (unsigned)hold & 0xffff;
3035             Tracev((stderr, "inflate:       stored length %u\n",
3036                     state->length));
3037             INITBITS();
3038             state->mode = COPY;
3039         case COPY:
3040             copy = state->length;
3041             if (copy) {
3042                 if (copy > have) copy = have;
3043                 if (copy > left) copy = left;
3044                 if (copy == 0) goto inf_leave;
3045                 zmemcpy(put, next, copy);
3046                 have -= copy;
3047                 next += copy;
3048                 left -= copy;
3049                 put += copy;
3050                 state->length -= copy;
3051                 break;
3052             }
3053             Tracev((stderr, "inflate:       stored end\n"));
3054             state->mode = TYPE;
3055             break;
3056         case TABLE:
3057             NEEDBITS(14);
3058             state->nlen = BITS(5) + 257;
3059             DROPBITS(5);
3060             state->ndist = BITS(5) + 1;
3061             DROPBITS(5);
3062             state->ncode = BITS(4) + 4;
3063             DROPBITS(4);
3064 #ifndef PKZIP_BUG_WORKAROUND
3065             if (state->nlen > 286 || state->ndist > 30) {
3066                 strm->msg = (char *)"too many length or distance symbols";
3067                 state->mode = BAD;
3068                 break;
3069             }
3070 #endif
3071             Tracev((stderr, "inflate:       table sizes ok\n"));
3072             state->have = 0;
3073             state->mode = LENLENS;
3074         case LENLENS:
3075             while (state->have < state->ncode) {
3076                 NEEDBITS(3);
3077                 state->lens[order[state->have++]] = (unsigned short)BITS(3);
3078                 DROPBITS(3);
3079             }
3080             while (state->have < 19)
3081                 state->lens[order[state->have++]] = 0;
3082             state->next = state->codes;
3083             state->lencode = (code const FAR *)(state->next);
3084             state->lenbits = 7;
3085             ret = inflate_table(CODES, state->lens, 19, &(state->next),
3086                                 &(state->lenbits), state->work);
3087             if (ret) {
3088                 strm->msg = (char *)"invalid code lengths set";
3089                 state->mode = BAD;
3090                 break;
3091             }
3092             Tracev((stderr, "inflate:       code lengths ok\n"));
3093             state->have = 0;
3094             state->mode = CODELENS;
3095         case CODELENS:
3096             while (state->have < state->nlen + state->ndist) {
3097                 for (;;) {
3098                     this = state->lencode[BITS(state->lenbits)];
3099                     if ((unsigned)(this.bits) <= bits) break;
3100                     PULLBYTE();
3101                 }
3102                 if (this.val < 16) {
3103                     NEEDBITS(this.bits);
3104                     DROPBITS(this.bits);
3105                     state->lens[state->have++] = this.val;
3106                 }
3107                 else {
3108                     if (this.val == 16) {
3109                         NEEDBITS(this.bits + 2);
3110                         DROPBITS(this.bits);
3111                         if (state->have == 0) {
3112                             strm->msg = (char *)"invalid bit length repeat";
3113                             state->mode = BAD;
3114                             break;
3115                         }
3116                         len = state->lens[state->have - 1];
3117                         copy = 3 + BITS(2);
3118                         DROPBITS(2);
3119                     }
3120                     else if (this.val == 17) {
3121                         NEEDBITS(this.bits + 3);
3122                         DROPBITS(this.bits);
3123                         len = 0;
3124                         copy = 3 + BITS(3);
3125                         DROPBITS(3);
3126                     }
3127                     else {
3128                         NEEDBITS(this.bits + 7);
3129                         DROPBITS(this.bits);
3130                         len = 0;
3131                         copy = 11 + BITS(7);
3132                         DROPBITS(7);
3133                     }
3134                     if (state->have + copy > state->nlen + state->ndist) {
3135                         strm->msg = (char *)"invalid bit length repeat";
3136                         state->mode = BAD;
3137                         break;
3138                     }
3139                     while (copy--)
3140                         state->lens[state->have++] = (unsigned short)len;
3141                 }
3142             }
3143
3144             /* handle error breaks in while */
3145             if (state->mode == BAD) break;
3146
3147             /* build code tables */
3148             state->next = state->codes;
3149             state->lencode = (code const FAR *)(state->next);
3150             state->lenbits = 9;
3151             ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
3152                                 &(state->lenbits), state->work);
3153             if (ret) {
3154                 strm->msg = (char *)"invalid literal/lengths set";
3155                 state->mode = BAD;
3156                 break;
3157             }
3158             state->distcode = (code const FAR *)(state->next);
3159             state->distbits = 6;
3160             ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
3161                             &(state->next), &(state->distbits), state->work);
3162             if (ret) {
3163                 strm->msg = (char *)"invalid distances set";
3164                 state->mode = BAD;
3165                 break;
3166             }
3167             Tracev((stderr, "inflate:       codes ok\n"));
3168             state->mode = LEN;
3169         case LEN:
3170             if (have >= 6 && left >= 258) {
3171                 RESTORE();
3172                 inflate_fast(strm, out);
3173                 LOAD();
3174                 break;
3175             }
3176             for (;;) {
3177                 this = state->lencode[BITS(state->lenbits)];
3178                 if ((unsigned)(this.bits) <= bits) break;
3179                 PULLBYTE();
3180             }
3181             if (this.op && (this.op & 0xf0) == 0) {
3182                 last = this;
3183                 for (;;) {
3184                     this = state->lencode[last.val +
3185                             (BITS(last.bits + last.op) >> last.bits)];
3186                     if ((unsigned)(last.bits + this.bits) <= bits) break;
3187                     PULLBYTE();
3188                 }
3189                 DROPBITS(last.bits);
3190             }
3191             DROPBITS(this.bits);
3192             state->length = (unsigned)this.val;
3193             if ((int)(this.op) == 0) {
3194                 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
3195                         "inflate:         literal '%c'\n" :
3196                         "inflate:         literal 0x%02x\n", this.val));
3197                 state->mode = LIT;
3198                 break;
3199             }
3200             if (this.op & 32) {
3201                 Tracevv((stderr, "inflate:         end of block\n"));
3202                 state->mode = TYPE;
3203                 break;
3204             }
3205             if (this.op & 64) {
3206                 strm->msg = (char *)"invalid literal/length code";
3207                 state->mode = BAD;
3208                 break;
3209             }
3210             state->extra = (unsigned)(this.op) & 15;
3211             state->mode = LENEXT;
3212         case LENEXT:
3213             if (state->extra) {
3214                 NEEDBITS(state->extra);
3215                 state->length += BITS(state->extra);
3216                 DROPBITS(state->extra);
3217             }
3218             Tracevv((stderr, "inflate:         length %u\n", state->length));
3219             state->mode = DIST;
3220         case DIST:
3221             for (;;) {
3222                 this = state->distcode[BITS(state->distbits)];
3223                 if ((unsigned)(this.bits) <= bits) break;
3224                 PULLBYTE();
3225             }
3226             if ((this.op & 0xf0) == 0) {
3227                 last = this;
3228                 for (;;) {
3229                     this = state->distcode[last.val +
3230                             (BITS(last.bits + last.op) >> last.bits)];
3231                     if ((unsigned)(last.bits + this.bits) <= bits) break;
3232                     PULLBYTE();
3233                 }
3234                 DROPBITS(last.bits);
3235             }
3236             DROPBITS(this.bits);
3237             if (this.op & 64) {
3238                 strm->msg = (char *)"invalid distance code";
3239                 state->mode = BAD;
3240                 break;
3241             }
3242             state->offset = (unsigned)this.val;
3243             state->extra = (unsigned)(this.op) & 15;
3244             state->mode = DISTEXT;
3245         case DISTEXT:
3246             if (state->extra) {
3247                 NEEDBITS(state->extra);
3248                 state->offset += BITS(state->extra);
3249                 DROPBITS(state->extra);
3250             }
3251 #ifdef INFLATE_STRICT
3252             if (state->offset > state->dmax) {
3253                 strm->msg = (char *)"invalid distance too far back";
3254                 state->mode = BAD;
3255                 break;
3256             }
3257 #endif
3258             if (state->offset > state->whave + out - left) {
3259                 strm->msg = (char *)"invalid distance too far back";
3260                 state->mode = BAD;
3261                 break;
3262             }
3263             Tracevv((stderr, "inflate:         distance %u\n", state->offset));
3264             state->mode = MATCH;
3265         case MATCH:
3266             if (left == 0) goto inf_leave;
3267             copy = out - left;
3268             if (state->offset > copy) {         /* copy from window */
3269                 copy = state->offset - copy;
3270                 if (copy > state->write) {
3271                     copy -= state->write;
3272                     from = state->window + (state->wsize - copy);
3273                 }
3274                 else
3275                     from = state->window + (state->write - copy);
3276                 if (copy > state->length) copy = state->length;
3277             }
3278             else {                              /* copy from output */
3279                 from = put - state->offset;
3280                 copy = state->length;
3281             }
3282             if (copy > left) copy = left;
3283             left -= copy;
3284             state->length -= copy;
3285             do {
3286                 *put++ = *from++;
3287             } while (--copy);
3288             if (state->length == 0) state->mode = LEN;
3289             break;
3290         case LIT:
3291             if (left == 0) goto inf_leave;
3292             *put++ = (unsigned char)(state->length);
3293             left--;
3294             state->mode = LEN;
3295             break;
3296         case CHECK:
3297             if (state->wrap) {
3298                 NEEDBITS(32);
3299                 out -= left;
3300                 strm->total_out += out;
3301                 state->total += out;
3302                 if (out)
3303                     strm->adler = state->check =
3304                         UPDATE(state->check, put - out, out);
3305                 out = left;
3306                 if ((
3307 #ifdef GUNZIP
3308                      state->flags ? hold :
3309 #endif
3310                      REVERSE(hold)) != state->check) {
3311                     strm->msg = (char *)"incorrect data check";
3312                     state->mode = BAD;
3313                     break;
3314                 }
3315                 INITBITS();
3316                 Tracev((stderr, "inflate:   check matches trailer\n"));
3317             }
3318 #ifdef GUNZIP
3319             state->mode = LENGTH;
3320         case LENGTH:
3321             if (state->wrap && state->flags) {
3322                 NEEDBITS(32);
3323                 if (hold != (state->total & 0xffffffff)) {
3324                     strm->msg = (char *)"incorrect length check";
3325                     state->mode = BAD;
3326                     break;
3327                 }
3328                 INITBITS();
3329                 Tracev((stderr, "inflate:   length matches trailer\n"));
3330             }
3331 #endif
3332             state->mode = DONE;
3333         case DONE:
3334             ret = Z_STREAM_END;
3335             goto inf_leave;
3336         case BAD:
3337             ret = Z_DATA_ERROR;
3338             goto inf_leave;
3339         case MEM:
3340             return Z_MEM_ERROR;
3341         case SYNC:
3342         default:
3343             return Z_STREAM_ERROR;
3344         }
3345
3346     /*
3347        Return from inflate(), updating the total counts and the check value.
3348        If there was no progress during the inflate() call, return a buffer
3349        error.  Call updatewindow() to create and/or update the window state.
3350        Note: a memory error from inflate() is non-recoverable.
3351      */
3352   inf_leave:
3353     RESTORE();
3354     if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
3355         if (updatewindow(strm, out)) {
3356             state->mode = MEM;
3357             return Z_MEM_ERROR;
3358         }
3359     in -= strm->avail_in;
3360     out -= strm->avail_out;
3361     strm->total_in += in;
3362     strm->total_out += out;
3363     state->total += out;
3364     if (state->wrap && out)
3365         strm->adler = state->check =
3366             UPDATE(state->check, strm->next_out - out, out);
3367     strm->data_type = state->bits + (state->last ? 64 : 0) +
3368                       (state->mode == TYPE ? 128 : 0);
3369     if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
3370         ret = Z_BUF_ERROR;
3371     return ret;
3372 }
3373
3374 int ZEXPORT inflateEnd(strm)
3375 z_streamp strm;
3376 {
3377     struct inflate_state FAR *state;
3378     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
3379         return Z_STREAM_ERROR;
3380     state = (struct inflate_state FAR *)strm->state;
3381     if (state->window != Z_NULL) ZFREE(strm, state->window);
3382     ZFREE(strm, strm->state);
3383     strm->state = Z_NULL;
3384     Tracev((stderr, "inflate: end\n"));
3385     return Z_OK;
3386 }
3387
3388 int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
3389 z_streamp strm;
3390 const Bytef *dictionary;
3391 uInt dictLength;
3392 {
3393     struct inflate_state FAR *state;
3394     unsigned long id;
3395
3396     /* check state */
3397     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
3398     state = (struct inflate_state FAR *)strm->state;
3399     if (state->wrap != 0 && state->mode != DICT)
3400         return Z_STREAM_ERROR;
3401
3402     /* check for correct dictionary id */
3403     if (state->mode == DICT) {
3404         id = adler32(0L, Z_NULL, 0);
3405         id = adler32(id, dictionary, dictLength);
3406         if (id != state->check)
3407             return Z_DATA_ERROR;
3408     }
3409
3410     /* copy dictionary to window */
3411     if (updatewindow(strm, strm->avail_out)) {
3412         state->mode = MEM;
3413         return Z_MEM_ERROR;
3414     }
3415     if (dictLength > state->wsize) {
3416         zmemcpy(state->window, dictionary + dictLength - state->wsize,
3417                 state->wsize);
3418         state->whave = state->wsize;
3419     }
3420     else {
3421         zmemcpy(state->window + state->wsize - dictLength, dictionary,
3422                 dictLength);
3423         state->whave = dictLength;
3424     }
3425     state->havedict = 1;
3426     Tracev((stderr, "inflate:   dictionary set\n"));
3427     return Z_OK;
3428 }
3429
3430 int ZEXPORT inflateGetHeader(strm, head)
3431 z_streamp strm;
3432 gz_headerp head;
3433 {
3434     struct inflate_state FAR *state;
3435
3436     /* check state */
3437     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
3438     state = (struct inflate_state FAR *)strm->state;
3439     if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
3440
3441     /* save header structure */
3442     state->head = head;
3443 #ifdef GUNZIP
3444     head->done = 0;
3445 #endif
3446     return Z_OK;
3447 }
3448
3449 /*
3450    Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
3451    or when out of input.  When called, *have is the number of pattern bytes
3452    found in order so far, in 0..3.  On return *have is updated to the new
3453    state.  If on return *have equals four, then the pattern was found and the
3454    return value is how many bytes were read including the last byte of the
3455    pattern.  If *have is less than four, then the pattern has not been found
3456    yet and the return value is len.  In the latter case, syncsearch() can be
3457    called again with more data and the *have state.  *have is initialized to
3458    zero for the first call.
3459  */
3460 local unsigned syncsearch(have, buf, len)
3461 unsigned FAR *have;
3462 unsigned char FAR *buf;
3463 unsigned len;
3464 {
3465     unsigned got;
3466     unsigned next;
3467
3468     got = *have;
3469     next = 0;
3470     while (next < len && got < 4) {
3471         if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
3472             got++;
3473         else if (buf[next])
3474             got = 0;
3475         else
3476             got = 4 - got;
3477         next++;
3478     }
3479     *have = got;
3480     return next;
3481 }
3482
3483 int ZEXPORT inflateSync(strm)
3484 z_streamp strm;
3485 {
3486     unsigned len;               /* number of bytes to look at or looked at */
3487     unsigned long in, out;      /* temporary to save total_in and total_out */
3488     unsigned char buf[4];       /* to restore bit buffer to byte string */
3489     struct inflate_state FAR *state;
3490
3491     /* check parameters */
3492     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
3493     state = (struct inflate_state FAR *)strm->state;
3494     if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
3495
3496     /* if first time, start search in bit buffer */
3497     if (state->mode != SYNC) {
3498         state->mode = SYNC;
3499         state->hold <<= state->bits & 7;
3500         state->bits -= state->bits & 7;
3501         len = 0;
3502         while (state->bits >= 8) {
3503             buf[len++] = (unsigned char)(state->hold);
3504             state->hold >>= 8;
3505             state->bits -= 8;
3506         }
3507         state->have = 0;
3508         syncsearch(&(state->have), buf, len);
3509     }
3510
3511     /* search available input */
3512     len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
3513     strm->avail_in -= len;
3514     strm->next_in += len;
3515     strm->total_in += len;
3516
3517     /* return no joy or set up to restart inflate() on a new block */
3518     if (state->have != 4) return Z_DATA_ERROR;
3519     in = strm->total_in;  out = strm->total_out;
3520     inflateReset(strm);
3521     strm->total_in = in;  strm->total_out = out;
3522     state->mode = TYPE;
3523     return Z_OK;
3524 }
3525
3526 /*
3527    Returns true if inflate is currently at the end of a block generated by
3528    Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
3529    implementation to provide an additional safety check. PPP uses
3530    Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
3531    block. When decompressing, PPP checks that at the end of input packet,
3532    inflate is waiting for these length bytes.
3533  */
3534 int ZEXPORT inflateSyncPoint(strm)
3535 z_streamp strm;
3536 {
3537     struct inflate_state FAR *state;
3538
3539     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
3540     state = (struct inflate_state FAR *)strm->state;
3541     return state->mode == STORED && state->bits == 0;
3542 }
3543
3544 int ZEXPORT inflateCopy(dest, source)
3545 z_streamp dest;
3546 z_streamp source;
3547 {
3548     struct inflate_state FAR *state;
3549     struct inflate_state FAR *copy;
3550     unsigned char FAR *window;
3551     unsigned wsize;
3552
3553     /* check input */
3554     if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
3555         source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
3556         return Z_STREAM_ERROR;
3557     state = (struct inflate_state FAR *)source->state;
3558
3559     /* allocate space */
3560     copy = (struct inflate_state FAR *)
3561            ZALLOC(source, 1, sizeof(struct inflate_state));
3562     if (copy == Z_NULL) return Z_MEM_ERROR;
3563     window = Z_NULL;
3564     if (state->window != Z_NULL) {
3565         window = (unsigned char FAR *)
3566                  ZALLOC(source, ((unsigned int)1) << state->wbits, sizeof(unsigned char));
3567         if (window == Z_NULL) {
3568             ZFREE(source, copy);
3569             return Z_MEM_ERROR;
3570         }
3571     }
3572
3573     /* copy state */
3574     zmemcpy(dest, source, sizeof(z_stream));
3575     zmemcpy(copy, state, sizeof(struct inflate_state));
3576     if (state->lencode >= state->codes &&
3577         state->lencode <= state->codes + ENOUGH - 1) {
3578         copy->lencode = copy->codes + (state->lencode - state->codes);
3579         copy->distcode = copy->codes + (state->distcode - state->codes);
3580     }
3581     copy->next = copy->codes + (state->next - state->codes);
3582     if (window != Z_NULL) {
3583         wsize = ((unsigned int)1) << state->wbits;
3584         zmemcpy(window, state->window, wsize);
3585     }
3586     copy->window = window;
3587     dest->state = (struct internal_state FAR *)copy;
3588     return Z_OK;
3589 }
3590
3591 #endif /* _INFLATE_C */
3592
3593 #ifndef _GZIO_C
3594 #define _GZIO_C         1
3595
3596 typedef voidp gzFile;
3597
3598 #ifndef Z_BUFSIZE
3599 #  ifdef MAXSEG_64K
3600 #    define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
3601 #  else
3602 #    define Z_BUFSIZE 16384
3603 #  endif
3604 #endif
3605 #ifndef Z_PRINTF_BUFSIZE
3606 #  define Z_PRINTF_BUFSIZE 4096
3607 #endif
3608
3609 #ifdef __MVS__
3610 #  pragma map (fdopen , "\174\174FDOPEN")
3611    FILE *fdopen(int, const char *);
3612 #endif
3613
3614 #if 0 && !_PACKAGE_ast
3615 #ifndef STDC
3616 extern voidp  malloc OF((uInt size));
3617 extern void   free   OF((voidpf ptr));
3618 #endif
3619 #endif
3620
3621 #define ALLOC(size) malloc(size)
3622 #define TRYFREE(p) {if (p) free(p);}
3623
3624 static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
3625
3626 /* gzip flag byte */
3627 #define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
3628 #define HEAD_CRC     0x02 /* bit 1 set: header CRC present */
3629 #define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
3630 #define ORIG_NAME    0x08 /* bit 3 set: original file name present */
3631 #define COMMENT      0x10 /* bit 4 set: file comment present */
3632 #define RESERVED     0xE0 /* bits 5..7: reserved */
3633
3634 typedef struct gz_stream {
3635     z_stream stream;
3636     int      z_err;   /* error code for last stream operation */
3637     int      z_eof;   /* set if end of input file */
3638     FILE     *file;   /* .gz file */
3639     Byte     *inbuf;  /* input buffer */
3640     Byte     *outbuf; /* output buffer */
3641     uLong    crc;     /* crc32 of uncompressed data */
3642     char     *msg;    /* error message */
3643     char     *path;   /* path name for debugging only */
3644     int      transparent; /* 1 if input file is not a .gz file */
3645 #if _PACKAGE_ast
3646     int      fatal;   /* fatal stream error => all other ops fail */
3647     int      nocrc;   /* 1 to skip 'r' crc checks */
3648     int      noclose; /* 1 to skip destroy fclose */
3649     int      verified;/* 2-byte magic read and verified ('v') */
3650 #endif
3651     char     mode;    /* 'w' or 'r' */
3652     z_off_t  start;   /* start of compressed data in file (header skipped) */
3653     z_off_t  in;      /* bytes into deflate or inflate */
3654     z_off_t  out;     /* bytes out of deflate or inflate */
3655     int      back;    /* one character push-back */
3656     int      last;    /* true if push-back is last character */
3657 } gz_stream;
3658
3659
3660 local gzFile gz_open      OF((const char *path, const char *mode, FILE* fp));
3661 local int    get_byte     OF((gz_stream *s));
3662 local void   check_header OF((gz_stream *s));
3663 local int    destroy      OF((gz_stream *s));
3664 local uLong  getLong      OF((gz_stream *s));
3665
3666 /* ===========================================================================
3667      Opens a gzip (.gz) file for reading or writing. The mode parameter
3668    is as in fopen ("rb" or "wb"). The file is given either by FILE pointer
3669    or path name (if fp == 0).
3670      gz_open returns NULL if the file could not be opened or if there was
3671    insufficient memory to allocate the (de)compression state; errno
3672    can be checked to distinguish the two cases (if errno is zero, the
3673    zlib error is Z_MEM_ERROR).
3674 */
3675 local gzFile gz_open (path, mode, fp)
3676     const char *path;
3677     const char *mode;
3678     FILE       *fp;
3679 {
3680     int err;
3681     int level = Z_DEFAULT_COMPRESSION; /* compression level */
3682     int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
3683     char *p = (char*)mode;
3684     gz_stream *s;
3685     char fmode[80]; /* copy of mode, without the compression level */
3686     char *m = fmode;
3687
3688     if (!path || !mode) return Z_NULL;
3689
3690     s = (gz_stream *)ALLOC(sizeof(gz_stream));
3691     if (!s) return Z_NULL;
3692
3693     s->stream.zalloc = (alloc_func)0;
3694     s->stream.zfree = (free_func)0;
3695     s->stream.opaque = (voidpf)0;
3696     s->stream.next_in = s->inbuf = Z_NULL;
3697     s->stream.next_out = s->outbuf = Z_NULL;
3698     s->stream.avail_in = s->stream.avail_out = 0;
3699     s->file = NULL;
3700     s->z_err = Z_OK;
3701     s->z_eof = 0;
3702     s->in = 0;
3703     s->out = 0;
3704     s->back = EOF;
3705     s->crc = crc32(0L, Z_NULL, 0);
3706 #if _PACKAGE_ast
3707     s->fatal = 0;
3708     s->nocrc = 0;
3709     s->verified = 0;
3710 #endif
3711     s->msg = NULL;
3712     s->transparent = 0;
3713
3714     s->path = (char*)ALLOC(strlen(path)+1);
3715     if (s->path == NULL) {
3716         return destroy(s), (gzFile)Z_NULL;
3717     }
3718     strcpy(s->path, path); /* do this early for debugging */
3719
3720     s->mode = '\0';
3721     do {
3722         if (*p == 'r') s->mode = 'r';
3723         if (*p == 'w' || *p == 'a') s->mode = 'w';
3724         if (*p >= '0' && *p <= '9') {
3725             level = *p - '0';
3726         } else if (*p == 'f') {
3727           strategy = Z_FILTERED;
3728         } else if (*p == 'h') {
3729           strategy = Z_HUFFMAN_ONLY;
3730         } else if (*p == 'R') {
3731           strategy = Z_RLE;
3732 #if _PACKAGE_ast
3733         } else if (*p == 'n') {
3734           s->nocrc = 1;
3735         } else if (*p == 'o') {
3736           s->noclose = 1;
3737         } else if (*p == 'v') {
3738           s->verified = 1;
3739 #endif
3740         } else {
3741             *m++ = *p; /* copy the mode */
3742         }
3743     } while (*p++ && m != fmode + sizeof(fmode));
3744     if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
3745
3746     if (s->mode == 'w') {
3747 #ifdef NO_GZCOMPRESS
3748         err = Z_STREAM_ERROR;
3749 #else
3750 #if _PACKAGE_ast
3751         s->nocrc = 0;
3752 #endif
3753         err = deflateInit2(&(s->stream), level,
3754                            Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
3755         /* windowBits is passed < 0 to suppress zlib header */
3756
3757         s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
3758 #endif
3759         if (err != Z_OK || s->outbuf == Z_NULL) {
3760             return destroy(s), (gzFile)Z_NULL;
3761         }
3762     } else {
3763         s->stream.next_in  = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
3764
3765         err = inflateInit2(&(s->stream), -MAX_WBITS);
3766         /* windowBits is passed < 0 to tell that there is no zlib header.
3767          * Note that in this case inflate *requires* an extra "dummy" byte
3768          * after the compressed stream in order to complete decompression and
3769          * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
3770          * present after the compressed stream.
3771          */
3772         if (err != Z_OK || s->inbuf == Z_NULL) {
3773             return destroy(s), (gzFile)Z_NULL;
3774         }
3775     }
3776     s->stream.avail_out = Z_BUFSIZE;
3777
3778     errno = 0;
3779
3780     if (!(s->file = fp) && !(s->file = F_OPEN(path, fmode))) {
3781         return destroy(s), (gzFile)Z_NULL;
3782     }
3783     if (s->mode == 'w') {
3784         /* Write a very simple .gz header:
3785          */
3786         fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
3787              Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
3788         s->start = 10L;
3789         /* We use 10L instead of ftell(s->file) to because ftell causes an
3790          * fflush on some systems. This version of the library doesn't use
3791          * start anyway in write mode, so this initialization is not
3792          * necessary.
3793          */
3794     } else {
3795 #if _PACKAGE_ast
3796         sfsetbuf(s->file, (void*)s->file, SF_UNBOUND);
3797 #endif
3798         check_header(s); /* skip the .gz header */
3799         s->start = (z_off_t)(ftell(s->file) - s->stream.avail_in);
3800     }
3801
3802     return (gzFile)s;
3803 }
3804
3805 /* ===========================================================================
3806      Associate a gzFile with the stdio stream fp.
3807 */
3808 gzFile ZEXPORT gzfopen (fp, mode)
3809     FILE* fp;
3810     const char *mode;
3811 {
3812     FILE* sp = (FILE*)fp;
3813     char name[20];
3814
3815     if (!sp)
3816        return (gzFile)Z_NULL;
3817     sprintf(name, "<fd:%d>", fileno(sp)); /* for debugging */
3818
3819     return gz_open (name, mode, sp);
3820 }
3821
3822 /* ===========================================================================
3823      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
3824    for end of file.
3825    IN assertion: the stream s has been sucessfully opened for reading.
3826 */
3827 local int get_byte(s)
3828     gz_stream *s;
3829 {
3830     if (s->z_eof) return EOF;
3831     if (s->stream.avail_in == 0) {
3832         errno = 0;
3833         s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
3834         if (s->stream.avail_in == 0) {
3835             s->z_eof = 1;
3836             if (ferror(s->file)) s->z_err = Z_ERRNO;
3837             return EOF;
3838         }
3839         s->stream.next_in = s->inbuf;
3840     }
3841     s->stream.avail_in--;
3842     return *(s->stream.next_in)++;
3843 }
3844
3845 /* ===========================================================================
3846       Check the gzip header of a gz_stream opened for reading. Set the stream
3847     mode to transparent if the gzip magic header is not present; set s->err
3848     to Z_DATA_ERROR if the magic header is present but the rest of the header
3849     is incorrect.
3850     IN assertion: the stream s has already been created sucessfully;
3851        s->stream.avail_in is zero for the first time, but may be non-zero
3852        for concatenated .gz files.
3853 */
3854 local void check_header(s)
3855     gz_stream *s;
3856 {
3857     int method; /* method byte */
3858     int flags;  /* flags byte */
3859     uInt len;
3860     int c;
3861
3862 #if _PACKAGE_ast
3863     if (!s->verified)
3864         for (len = 0; len < 2; len++) {
3865             c = get_byte(s);
3866             if (c != gz_magic[len]) {
3867                 if (len != 0) s->stream.avail_in++, s->stream.next_in--;
3868                 if (c != EOF) {
3869                     s->stream.avail_in++, s->stream.next_in--;
3870                     s->transparent = 1;
3871                 }
3872                 s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
3873                 return;
3874             }
3875         }
3876 #else
3877     /* Assure two bytes in the buffer so we can peek ahead -- handle case
3878        where first byte of header is at the end of the buffer after the last
3879        gzip segment */
3880     len = s->stream.avail_in;
3881     if (len < 2) {
3882         if (len) s->inbuf[0] = s->stream.next_in[0];
3883         errno = 0;
3884         len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
3885         if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
3886         s->stream.avail_in += len;
3887         s->stream.next_in = s->inbuf;
3888         if (s->stream.avail_in < 2) {
3889             s->transparent = s->stream.avail_in;
3890             return;
3891         }
3892     }
3893
3894     /* Peek ahead to check the gzip magic header */
3895     if (s->stream.next_in[0] != gz_magic[0] ||
3896         s->stream.next_in[1] != gz_magic[1]) {
3897         s->transparent = 1;
3898         return;
3899     }
3900     s->stream.avail_in -= 2;
3901     s->stream.next_in += 2;
3902 #endif
3903
3904     /* Check the rest of the gzip header */
3905     method = get_byte(s);
3906     flags = get_byte(s);
3907     if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
3908         s->z_err = Z_DATA_ERROR;
3909         return;
3910     }
3911
3912     /* Discard time, xflags and OS code: */
3913     for (len = 0; len < 6; len++) (void)get_byte(s);
3914
3915     if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
3916         len  =  (uInt)get_byte(s);
3917         len += ((uInt)get_byte(s))<<8;
3918         /* len is garbage if EOF but the loop below will quit anyway */
3919         while (len-- != 0 && get_byte(s) != EOF) ;
3920     }
3921     if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
3922         while ((c = get_byte(s)) != 0 && c != EOF) ;
3923     }
3924     if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
3925         while ((c = get_byte(s)) != 0 && c != EOF) ;
3926     }
3927     if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
3928         for (len = 0; len < 2; len++) (void)get_byte(s);
3929     }
3930     s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
3931 }
3932
3933  /* ===========================================================================
3934  * Cleanup then free the given gz_stream. Return a zlib error code.
3935    Try freeing in the reverse order of allocations.
3936  */
3937 local int destroy (s)
3938     gz_stream *s;
3939 {
3940     int err = Z_OK;
3941
3942     if (!s) return Z_STREAM_ERROR;
3943
3944     TRYFREE(s->msg);
3945
3946     if (s->stream.state != NULL) {
3947         if (s->mode == 'w') {
3948 #ifdef NO_GZCOMPRESS
3949             err = Z_STREAM_ERROR;
3950 #else
3951             err = deflateEnd(&(s->stream));
3952 #endif
3953         } else if (s->mode == 'r') {
3954             err = inflateEnd(&(s->stream));
3955         }
3956     }
3957 #if _PACKAGE_ast
3958     if (s->file != NULL && (s->noclose ? (s->mode == 'r' ? 0 : fflush(s->file)) : fclose(s->file))) {
3959 #else
3960     if (s->file != NULL && fclose(s->file)) {
3961 #endif
3962 #ifdef ESPIPE
3963         if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
3964 #endif
3965             err = Z_ERRNO;
3966     }
3967     if (s->z_err < 0) err = s->z_err;
3968
3969     TRYFREE(s->inbuf);
3970     TRYFREE(s->outbuf);
3971     TRYFREE(s->path);
3972     TRYFREE(s);
3973     return err;
3974 }
3975
3976 /* ===========================================================================
3977      Reads the given number of uncompressed bytes from the compressed file.
3978    gzread returns the number of bytes actually read (0 for end of file).
3979 */
3980 int ZEXPORT gzread (file, buf, len)
3981     gzFile file;
3982     voidp buf;
3983     unsigned len;
3984 {
3985     gz_stream *s = (gz_stream*)file;
3986     Bytef *start = (Bytef*)buf; /* starting point for crc computation */
3987     Byte  *next_out; /* == stream.next_out but not forced far (for MSDOS) */
3988
3989     if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
3990
3991     if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
3992     if (s->z_err == Z_STREAM_END) return 0;  /* EOF */
3993
3994     next_out = (Byte*)buf;
3995     s->stream.next_out = (Bytef*)buf;
3996     s->stream.avail_out = len;
3997
3998     if (s->stream.avail_out && s->back != EOF) {
3999         *next_out++ = s->back;
4000         s->stream.next_out++;
4001         s->stream.avail_out--;
4002         s->back = EOF;
4003         s->out++;
4004         start++;
4005         if (s->last) {
4006             s->z_err = Z_STREAM_END;
4007             return 1;
4008         }
4009     }
4010
4011     while (s->stream.avail_out != 0) {
4012
4013         if (s->transparent) {
4014             /* Copy first the lookahead bytes: */
4015             uInt n = s->stream.avail_in;
4016             if (n > s->stream.avail_out) n = s->stream.avail_out;
4017             if (n > 0) {
4018                 zmemcpy(s->stream.next_out, s->stream.next_in, n);
4019                 next_out += n;
4020                 s->stream.next_out = next_out;
4021                 s->stream.next_in   += n;
4022                 s->stream.avail_out -= n;
4023                 s->stream.avail_in  -= n;
4024             }
4025             if (s->stream.avail_out > 0) {
4026                 s->stream.avail_out -=
4027                     (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
4028             }
4029             len -= s->stream.avail_out;
4030             s->in  += len;
4031             s->out += len;
4032             if (len == 0) s->z_eof = 1;
4033             return (int)len;
4034         }
4035         if (s->stream.avail_in == 0 && !s->z_eof) {
4036
4037             errno = 0;
4038             s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
4039             if (s->stream.avail_in == 0) {
4040                 s->z_eof = 1;
4041                 if (ferror(s->file)) {
4042                     s->z_err = Z_ERRNO;
4043                     break;
4044                 }
4045             }
4046             s->stream.next_in = s->inbuf;
4047         }
4048         s->in += s->stream.avail_in;
4049         s->out += s->stream.avail_out;
4050         s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
4051         s->in -= s->stream.avail_in;
4052         s->out -= s->stream.avail_out;
4053
4054         if (s->z_err == Z_STREAM_END) {
4055             /* Check CRC and original size */
4056 #if _PACKAGE_ast
4057             if (!s->nocrc)
4058 #endif
4059             s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
4060             start = s->stream.next_out;
4061
4062 #if _PACKAGE_ast
4063             if (getLong(s) != s->crc && !s->nocrc) {
4064 #else
4065             if (getLong(s) != s->crc) {
4066 #endif
4067                 s->z_err = Z_DATA_ERROR;
4068             } else {
4069                 (void)getLong(s);
4070                 /* The uncompressed length returned by above getlong() may be
4071                  * different from s->out in case of concatenated .gz files.
4072                  * Check for such files:
4073                  */
4074                 check_header(s);
4075                 if (s->z_err == Z_OK) {
4076                     inflateReset(&(s->stream));
4077 #if _PACKAGE_ast
4078                     if (!s->nocrc)
4079 #endif
4080                     s->crc = crc32(0L, Z_NULL, 0);
4081 #if _PACKAGE_ast
4082                     else
4083                         s->z_err = Z_STREAM_END;
4084 #endif
4085                 }
4086             }
4087         }
4088         if (s->z_err != Z_OK || s->z_eof) break;
4089     }
4090 #if _PACKAGE_ast
4091     if (!s->nocrc)
4092 #endif
4093     s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
4094
4095     if (len == s->stream.avail_out &&
4096         (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
4097         return -1;
4098     return (int)(len - s->stream.avail_out);
4099 }
4100
4101 /* ===========================================================================
4102    Reads a long in LSB order from the given gz_stream. Sets z_err in case
4103    of error.
4104 */
4105 local uLong getLong (s)
4106     gz_stream *s;
4107 {
4108     uLong x = (uLong)get_byte(s);
4109     int c;
4110
4111     x += ((uLong)get_byte(s))<<8;
4112     x += ((uLong)get_byte(s))<<16;
4113     c = get_byte(s);
4114     if (c == EOF) s->z_err = Z_DATA_ERROR;
4115     x += ((uLong)c)<<24;
4116     return x;
4117 }
4118
4119 #endif /* _GZIO_C */
4120
4121 #endif /* _GUNZIP_H */
4122
4123 #undef  local
4124
4125 #ifndef _RATZ_C
4126 #define _RATZ_C         1
4127
4128 #include <sys/stat.h>
4129
4130 #ifndef S_IRUSR
4131 #define S_IRUSR         0400
4132 #endif
4133 #ifndef S_IWUSR
4134 #define S_IWUSR         0200
4135 #endif
4136 #ifndef S_IXUSR
4137 #define S_IXUSR         0100
4138 #endif
4139 #ifndef S_IRGRP
4140 #define S_IRGRP         0040
4141 #endif
4142 #ifndef S_IWGRP
4143 #define S_IWGRP         0020
4144 #endif
4145 #ifndef S_IXGRP
4146 #define S_IXGRP         0010
4147 #endif
4148 #ifndef S_IROTH
4149 #define S_IROTH         0004
4150 #endif
4151 #ifndef S_IWOTH
4152 #define S_IWOTH         0002
4153 #endif
4154 #ifndef S_IXOTH
4155 #define S_IXOTH         0001
4156 #endif
4157
4158 /*
4159  * Standard Archive Format
4160  * USTAR - Uniform Standard Tape ARchive
4161  */
4162
4163 #define TBLOCK          512
4164 #define NAMSIZ          100
4165 #define PFXSIZ          155
4166
4167 #define TMODLEN         8
4168 #define TUIDLEN         8
4169 #define TGIDLEN         8
4170 #define TSIZLEN         12
4171 #define TMTMLEN         12
4172 #define TCKSLEN         8
4173
4174 #define TMAGIC          "ustar"         /* ustar and a null             */
4175 #define TMAGLEN         6
4176 #define TVERSION        "00"            /* 00 and no null               */
4177 #define TVERSLEN        2
4178 #define TUNMLEN         32
4179 #define TGNMLEN         32
4180 #define TDEVLEN         8
4181 #define TPADLEN         12
4182
4183 /*
4184  * values used in typeflag field
4185  */
4186
4187 #define REGTYPE         '0'             /* regular file                 */
4188 #define AREGTYPE        0               /* alternate REGTYPE            */
4189 #define LNKTYPE         '1'             /* hard link                    */
4190 #define SYMTYPE         '2'             /* soft link                    */
4191 #define CHRTYPE         '3'             /* character special            */
4192 #define BLKTYPE         '4'             /* block special                */
4193 #define DIRTYPE         '5'             /* directory                    */
4194 #define FIFOTYPE        '6'             /* FIFO special                 */
4195 #define CONTTYPE        '7'             /* reserved                     */
4196 #define SOKTYPE         '8'             /* socket -- reserved           */
4197 #define VERTYPE         'V'             /* version -- reserved          */
4198 #define EXTTYPE         'x'             /* extended header -- reserved  */
4199
4200 /*
4201  * bits used in mode field
4202  */
4203
4204 #define TSUID           04000           /* set uid on exec              */
4205 #define TSGID           02000           /* set gid on exec              */
4206 #define TSVTX           01000           /* sticky bit -- reserved       */
4207
4208 /*
4209  * file permissions
4210  */
4211
4212 #define TUREAD          00400           /* read by owner                */
4213 #define TUWRITE         00200           /* write by owner               */
4214 #define TUEXEC          00100           /* execute by owner             */
4215 #define TGREAD          00040           /* read by group                */
4216 #define TGWRITE         00020           /* execute by group             */
4217 #define TGEXEC          00010           /* write by group               */
4218 #define TOREAD          00004           /* read by other                */
4219 #define TOWRITE         00002           /* write by other               */
4220 #define TOEXEC          00001           /* execute by other             */
4221
4222 #define TAR_SUMASK      ((1L<<(TCKSLEN-1)*3)-1)
4223
4224 typedef struct
4225 {
4226         char            name[NAMSIZ];
4227         char            mode[TMODLEN];
4228         char            uid[TUIDLEN];
4229         char            gid[TGIDLEN];
4230         char            size[TSIZLEN];
4231         char            mtime[TMTMLEN];
4232         char            chksum[TCKSLEN];
4233         char            typeflag;
4234         char            linkname[NAMSIZ];
4235         char            magic[TMAGLEN];
4236         char            version[TVERSLEN];
4237         char            uname[TUNMLEN];
4238         char            gname[TGNMLEN];
4239         char            devmajor[TDEVLEN];
4240         char            devminor[TDEVLEN];
4241         char            prefix[PFXSIZ];
4242         char            pad[TPADLEN];
4243 } Header_t;
4244
4245 static struct
4246 {
4247         char*           id;
4248         unsigned long   blocks;
4249         unsigned long   files;
4250 } state;
4251
4252 #if !_PACKAGE_ast
4253
4254 static void
4255 usage()
4256 {
4257 #if defined(_SEAR_EXEC) || defined(_SEAR_SEEK)
4258         fprintf(stderr, "Usage: %s [-ciklmntvV] [ [no]name[=value] ... ]\n", state.id);
4259 #else
4260         fprintf(stderr, "Usage: %s [-clmntvV] < input.tgz\n", state.id);
4261 #endif
4262         exit(2);
4263 }
4264
4265 #endif
4266
4267 /*
4268  * the X/Open dd EBCDIC table
4269  */
4270
4271 static const unsigned char a2e[] =
4272 {
4273         0000,0001,0002,0003,0067,0055,0056,0057,
4274         0026,0005,0045,0013,0014,0015,0016,0017,
4275         0020,0021,0022,0023,0074,0075,0062,0046,
4276         0030,0031,0077,0047,0034,0035,0036,0037,
4277         0100,0132,0177,0173,0133,0154,0120,0175,
4278         0115,0135,0134,0116,0153,0140,0113,0141,
4279         0360,0361,0362,0363,0364,0365,0366,0367,
4280         0370,0371,0172,0136,0114,0176,0156,0157,
4281         0174,0301,0302,0303,0304,0305,0306,0307,
4282         0310,0311,0321,0322,0323,0324,0325,0326,
4283         0327,0330,0331,0342,0343,0344,0345,0346,
4284         0347,0350,0351,0255,0340,0275,0232,0155,
4285         0171,0201,0202,0203,0204,0205,0206,0207,
4286         0210,0211,0221,0222,0223,0224,0225,0226,
4287         0227,0230,0231,0242,0243,0244,0245,0246,
4288         0247,0250,0251,0300,0117,0320,0137,0007,
4289         0040,0041,0042,0043,0044,0025,0006,0027,
4290         0050,0051,0052,0053,0054,0011,0012,0033,
4291         0060,0061,0032,0063,0064,0065,0066,0010,
4292         0070,0071,0072,0073,0004,0024,0076,0341,
4293         0101,0102,0103,0104,0105,0106,0107,0110,
4294         0111,0121,0122,0123,0124,0125,0126,0127,
4295         0130,0131,0142,0143,0144,0145,0146,0147,
4296         0150,0151,0160,0161,0162,0163,0164,0165,
4297         0166,0167,0170,0200,0212,0213,0214,0215,
4298         0216,0217,0220,0152,0233,0234,0235,0236,
4299         0237,0240,0252,0253,0254,0112,0256,0257,
4300         0260,0261,0262,0263,0264,0265,0266,0267,
4301         0270,0271,0272,0273,0274,0241,0276,0277,
4302         0312,0313,0314,0315,0316,0317,0332,0333,
4303         0334,0335,0336,0337,0352,0353,0354,0355,
4304         0356,0357,0372,0373,0374,0375,0376,0377,
4305 };
4306
4307 /*
4308  * the X/Open dd IBM table
4309  */
4310
4311 static const unsigned char a2i[] =
4312 {
4313         0000,0001,0002,0003,0067,0055,0056,0057,
4314         0026,0005,0045,0013,0014,0015,0016,0017,
4315         0020,0021,0022,0023,0074,0075,0062,0046,
4316         0030,0031,0077,0047,0034,0035,0036,0037,
4317         0100,0132,0177,0173,0133,0154,0120,0175,
4318         0115,0135,0134,0116,0153,0140,0113,0141,
4319         0360,0361,0362,0363,0364,0365,0366,0367,
4320         0370,0371,0172,0136,0114,0176,0156,0157,
4321         0174,0301,0302,0303,0304,0305,0306,0307,
4322         0310,0311,0321,0322,0323,0324,0325,0326,
4323         0327,0330,0331,0342,0343,0344,0345,0346,
4324         0347,0350,0351,0255,0340,0275,0137,0155,
4325         0171,0201,0202,0203,0204,0205,0206,0207,
4326         0210,0211,0221,0222,0223,0224,0225,0226,
4327         0227,0230,0231,0242,0243,0244,0245,0246,
4328         0247,0250,0251,0300,0117,0320,0241,0007,
4329         0040,0041,0042,0043,0044,0025,0006,0027,
4330         0050,0051,0052,0053,0054,0011,0012,0033,
4331         0060,0061,0032,0063,0064,0065,0066,0010,
4332         0070,0071,0072,0073,0004,0024,0076,0341,
4333         0101,0102,0103,0104,0105,0106,0107,0110,
4334         0111,0121,0122,0123,0124,0125,0126,0127,
4335         0130,0131,0142,0143,0144,0145,0146,0147,
4336         0150,0151,0160,0161,0162,0163,0164,0165,
4337         0166,0167,0170,0200,0212,0213,0214,0215,
4338         0216,0217,0220,0232,0233,0234,0235,0236,
4339         0237,0240,0252,0253,0254,0255,0256,0257,
4340         0260,0261,0262,0263,0264,0265,0266,0267,
4341         0270,0271,0272,0273,0274,0275,0276,0277,
4342         0312,0313,0314,0315,0316,0317,0332,0333,
4343         0334,0335,0336,0337,0352,0353,0354,0355,
4344         0356,0357,0372,0373,0374,0375,0376,0377,
4345 };
4346
4347 /*
4348  * the mvs OpenEdition EBCDIC table
4349  */
4350
4351 static const unsigned char a2o[] =
4352 {
4353         0000,0001,0002,0003,0067,0055,0056,0057,
4354         0026,0005,0025,0013,0014,0015,0016,0017,
4355         0020,0021,0022,0023,0074,0075,0062,0046,
4356         0030,0031,0077,0047,0034,0035,0036,0037,
4357         0100,0132,0177,0173,0133,0154,0120,0175,
4358         0115,0135,0134,0116,0153,0140,0113,0141,
4359         0360,0361,0362,0363,0364,0365,0366,0367,
4360         0370,0371,0172,0136,0114,0176,0156,0157,
4361         0174,0301,0302,0303,0304,0305,0306,0307,
4362         0310,0311,0321,0322,0323,0324,0325,0326,
4363         0327,0330,0331,0342,0343,0344,0345,0346,
4364         0347,0350,0351,0255,0340,0275,0137,0155,
4365         0171,0201,0202,0203,0204,0205,0206,0207,
4366         0210,0211,0221,0222,0223,0224,0225,0226,
4367         0227,0230,0231,0242,0243,0244,0245,0246,
4368         0247,0250,0251,0300,0117,0320,0241,0007,
4369         0040,0041,0042,0043,0044,0045,0006,0027,
4370         0050,0051,0052,0053,0054,0011,0012,0033,
4371         0060,0061,0032,0063,0064,0065,0066,0010,
4372         0070,0071,0072,0073,0004,0024,0076,0377,
4373         0101,0252,0112,0261,0237,0262,0152,0265,
4374         0273,0264,0232,0212,0260,0312,0257,0274,
4375         0220,0217,0352,0372,0276,0240,0266,0263,
4376         0235,0332,0233,0213,0267,0270,0271,0253,
4377         0144,0145,0142,0146,0143,0147,0236,0150,
4378         0164,0161,0162,0163,0170,0165,0166,0167,
4379         0254,0151,0355,0356,0353,0357,0354,0277,
4380         0200,0375,0376,0373,0374,0272,0256,0131,
4381         0104,0105,0102,0106,0103,0107,0234,0110,
4382         0124,0121,0122,0123,0130,0125,0126,0127,
4383         0214,0111,0315,0316,0313,0317,0314,0341,
4384         0160,0335,0336,0333,0334,0215,0216,0337,
4385 };
4386
4387 /*
4388  * ascii text vs. control
4389  */
4390
4391 static const unsigned char ascii_text[] =
4392 {
4393         0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,
4394         1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
4395         1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
4396         1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,
4397         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
4398         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
4399         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
4400         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
4401 };
4402
4403 static int
4404 block(fp, gz, buf)
4405 FILE*   fp;
4406 gzFile  gz;
4407 char*   buf;
4408 {
4409         int     r;
4410
4411         if (gz)
4412                 r = gzread(gz, buf, sizeof(Header_t)) == sizeof(Header_t);
4413         else
4414                 r = fread(buf, sizeof(Header_t), 1, fp) == 1;
4415         if (r)
4416                 state.blocks++;
4417         return r;
4418 }
4419
4420 static int
4421 skip(fp, gz, buf, n)
4422 FILE*           fp;
4423 gzFile          gz;
4424 char*           buf;
4425 unsigned long   n;
4426 {
4427         while (n > 0)
4428         {
4429                 if (!block(fp, gz, buf))
4430                 {
4431                         fprintf(stderr, "%s: unexpected EOF\n", state.id);
4432                         return 1;
4433                 }
4434                 if (n <= sizeof(Header_t))
4435                         break;
4436                 n -= sizeof(Header_t);
4437         }
4438         return 0;
4439 }
4440
4441 static unsigned long
4442 number(s)
4443 register char*  s;
4444 {
4445         unsigned long   n = 0;
4446
4447         while (*s == ' ')
4448                 s++;
4449         while (*s >= '0' && *s <= '7')
4450                 n = (n << 3) + (*s++ - '0');
4451         return n;
4452 }
4453
4454 #if defined(_SEAR_EXEC) || defined(_SEAR_SEEK)
4455
4456 #ifndef PATH_MAX
4457 #define PATH_MAX        256
4458 #endif
4459
4460 #define EXIT(n) return(sear_exec((char*)0,(char**)0,(char*)0,(n)))
4461
4462 static int      sear_stdin;
4463 static char*    sear_tmp;
4464 static char     sear_buf[PATH_MAX];
4465
4466 static int
4467 sear_seek(off_t offset, int tmp)
4468 {
4469         int     n;
4470         char    cmd[PATH_MAX];
4471
4472         GetModuleFileName(NULL, cmd, sizeof(cmd));
4473         sear_stdin = dup(0);
4474         close(0);
4475         if (open(cmd, O_BINARY|O_RDONLY) || lseek(0, offset, 0) != offset)
4476         {
4477                 fprintf(stderr, "%s: %s: cannot seek to data offset\n", state.id, cmd);
4478                 return -1;
4479         }
4480         if (tmp)
4481         {
4482                 if ((n = GetTempPath(sizeof(cmd), cmd)) <= 0 || n > sizeof(cmd))
4483                 {
4484                         fprintf(stderr, "%s: cannot determine temporary directory path\n", state.id);
4485                         return -1;
4486                 }
4487                 if (!GetTempFileName(cmd, "SEA", 0, sear_buf))
4488                 {
4489                         fprintf(stderr, "%s: cannot determine temporary file path\n", state.id);
4490                         return -1;
4491                 }
4492                 sear_tmp = sear_buf;
4493                 if (!DeleteFile(sear_tmp))
4494                 {
4495                         fprintf(stderr, "%s: %s: cannot initialize temporary directory\n", state.id, sear_tmp);
4496                         return -1;
4497                 }
4498                 if (!CreateDirectory(sear_tmp, NULL))
4499                 {
4500                         fprintf(stderr, "%s: %s: cannot create temporary directory\n", state.id, sear_tmp);
4501                         return -1;
4502                 }
4503                 if (!SetCurrentDirectory(sear_tmp))
4504                 {
4505                         fprintf(stderr, "%s: %s: cannot cd to temporary directory\n", state.id, sear_tmp);
4506                         return -1;
4507                 }
4508         }
4509         return 0;
4510 }
4511
4512 /*
4513  * remove dir and its subdirs
4514  */
4515
4516 static void
4517 sear_rm_r(char* dir)
4518 {
4519         WIN32_FIND_DATA info;
4520         HANDLE          hp;
4521
4522         if (!SetCurrentDirectory(dir))
4523                 return;
4524         if ((hp = FindFirstFile("*.*", &info)) != INVALID_HANDLE_VALUE)
4525         {
4526                 do
4527                 {
4528                         if (!(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
4529                         {
4530                                 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
4531                                         SetFileAttributes(info.cFileName, info.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY);
4532                                 DeleteFile(info.cFileName);
4533                         }
4534                         else if (info.cFileName[0] != '.' || info.cFileName[1] != 0 && (info.cFileName[1] != '.' || info.cFileName[2] != 0))
4535                                 sear_rm_r(info.cFileName);
4536                 } while(FindNextFile(hp, &info));
4537                 FindClose(hp);
4538         }
4539         if (SetCurrentDirectory(".."))
4540                 RemoveDirectory(dir);
4541 }
4542
4543 /*
4544  * system(3) without PATH search that should work on all windows variants
4545  */
4546
4547 static int
4548 sear_system(const char* command, int nowindow)
4549 {
4550         PROCESS_INFORMATION     pinfo;
4551         STARTUPINFO             sinfo;
4552         char*                   cp;
4553         char                    path[PATH_MAX];
4554         int                     n = *command == '"';
4555         DWORD                   flags = NORMAL_PRIORITY_CLASS;
4556
4557         strncpy(path, &command[n], PATH_MAX - 4);
4558         n = n ? '"' : ' ';
4559         for (cp = path; *cp; *cp++)
4560                 if (*cp == n)
4561                         break;
4562         *cp = 0;
4563         if (GetFileAttributes(path) == 0xffffffff && GetLastError() == ERROR_FILE_NOT_FOUND)
4564                 strcpy(cp, ".exe");
4565         ZeroMemory(&sinfo, sizeof(sinfo));
4566         if (nowindow)
4567                 flags |= CREATE_NO_WINDOW;
4568         if (!CreateProcess(path, (char*)command, 0, 0, TRUE, flags, NULL, NULL, &sinfo, &pinfo))
4569                 n = GetLastError() == ERROR_FILE_NOT_FOUND ? 127 : 126;
4570         else
4571         {
4572                 CloseHandle(pinfo.hThread);
4573                 WaitForSingleObject(pinfo.hProcess, INFINITE);
4574                 if (!GetExitCodeProcess(pinfo.hProcess, &n))
4575                         n = 1;
4576                 CloseHandle(pinfo.hProcess);
4577                 Sleep(2 * 1000);
4578         }
4579         return n;
4580 }
4581
4582 /*
4583  * copy t to f but no farther than e
4584  * next t returned
4585  */
4586
4587 static char*
4588 copy(char* t, const char* f, char* e)
4589 {
4590         while (t < e && *f)
4591                 *t++ = *f++;
4592         return t;
4593 }
4594
4595 /*
4596  * execute cmd, chdir .., and remove sear_tmp
4597  */
4598
4599 static int
4600 sear_exec(const char* cmd, char* const* arg, char* operands, int code)
4601 {
4602         const char*     a;
4603         char*           b;
4604         char*           e;
4605         int             r;
4606         int             sh;
4607         int             nowindow;
4608         char            buf[1024];
4609
4610         fflush(stdout);
4611         fflush(stderr);
4612         if (sear_tmp)
4613         {
4614                 close(0);
4615                 dup(sear_stdin);
4616                 close(sear_stdin);
4617                 nowindow = 0;
4618                 if (cmd)
4619                 {
4620                         if (arg)
4621                                 for (r = 0; arg[r]; r++)
4622                                         if (!strcmp(arg[r], "remote"))
4623                                         {
4624                                                 nowindow = 1;
4625                                                 break;
4626                                         }
4627                         sh = 0;
4628                         for (a = cmd; *a && *a != ' '; a++)
4629                                 if (a[0] == '.' && a[1] == 's' && a[2] == 'h' && (!a[3] || a[3] == ' '))
4630                                 {
4631                                         sh = 1;
4632                                         break;
4633                                 }
4634                         b = buf;
4635                         e = buf + sizeof(buf) - 1;
4636                         if (sh || arg)
4637                         {
4638                                 if (sh)
4639                                 {
4640                                         b = copy(b, "ksh.exe ", e);
4641                                         if (*cmd && *cmd != '/')
4642                                                 b = copy(b, "./", e);
4643                                 }
4644                                 b = copy(b, cmd, e);
4645                                 while (a = *arg++)
4646                                 {
4647                                         if ((e - b) < 3)
4648                                                 break;
4649                                         b = copy(b, " \"", e);
4650                                         b = copy(b, a, e);
4651                                         b = copy(b, "\"", e);
4652                                 }
4653                         }
4654                         if (operands)
4655                         {
4656                                 if (b == buf)
4657                                         b = copy(b, cmd, e);
4658                                 b = copy(b, " -- ", e);
4659                                 b = copy(b, operands, e);
4660                         }
4661                         if (b > buf)
4662                         {
4663                                 *b = 0;
4664                                 cmd = (const char*)buf;
4665                         }
4666                         r = sear_system(cmd, nowindow);
4667                 }
4668                 else
4669                         r = code;
4670                 if (code >= 0)
4671                         sear_rm_r(sear_tmp);
4672         }
4673         else
4674                 r = cmd ? 0 : code;
4675         return r;
4676 }
4677
4678 #else
4679
4680 #define EXIT(n) return(n)
4681
4682 #endif
4683
4684 int
4685 main(argc, argv)
4686 int     argc;
4687 char**  argv;
4688 {
4689         register int            c;
4690         register char*          s;
4691         register char*          t;
4692         register char*          e;
4693         unsigned long           n;
4694         unsigned long           m;
4695         const unsigned char*    a2x;
4696         int                     clear;
4697         int                     list;
4698         int                     local;
4699         int                     meter;
4700         int                     unzip;
4701         int                     verbose;
4702         unsigned int            mode;
4703         unsigned long           total;
4704         off_t                   pos;
4705         gzFile                  gz;
4706         FILE*                   fp;
4707         Header_t                header;
4708         unsigned char           num[4];
4709         char                    path[sizeof(header.prefix) + sizeof(header.name) + 4];
4710         char                    buf[sizeof(header)];
4711 #if defined(_SEAR_OPTS)
4712         char*                   opts[4];
4713 #endif
4714
4715 #if defined(_SEAR_EXEC) || defined(_SEAR_SEEK)
4716         int                     install = 1;
4717 #endif
4718
4719         setmode(0, O_BINARY);
4720         setmode(1, O_BINARY);
4721         clear = 0;
4722         list = 0;
4723         local = 0;
4724         meter = 0;
4725         unzip = 0;
4726         verbose = 0;
4727         if (s = *argv)
4728         {
4729                 t = s;
4730                 while (*s)
4731                         if (*s++ == '/')
4732                                 t = s;
4733                 if (!strcmp(t, "gunzip"))
4734                         unzip = 1;
4735                 state.id = t;
4736         }
4737         else
4738                 state.id = "ratz";
4739         switch ('~')
4740         {
4741         case 0241:
4742                 switch ('\n')
4743                 {
4744                 case 0025:
4745                         a2x = a2o;
4746                         break;
4747                 default:
4748                         a2x = a2e;
4749                         break;
4750                 }
4751                 break;
4752         case 0137:
4753                 a2x = a2i;
4754                 break;
4755         default:
4756                 a2x = 0;
4757                 break;
4758         }
4759 #if defined(_SEAR_OPTS)
4760         opts[0] = argv[0];
4761         opts[1] = _SEAR_OPTS;
4762         opts[2] = argv[1];
4763         opts[3] = 0;
4764         argv = opts;
4765 #endif
4766 #if _PACKAGE_ast
4767         error_info.id = state.id;
4768         for (;;)
4769         {
4770                 switch (optget(argv, usage))
4771                 {
4772                 case 'c':
4773                         unzip = 1;
4774                         continue;
4775 #if defined(_SEAR_EXEC) || defined(_SEAR_SEEK)
4776                 case 'i':
4777                         install = 0;
4778                         continue;
4779                 case 'k':
4780                         install = -1;
4781                         continue;
4782 #endif
4783                 case 'l':
4784                         local = 1;
4785                         continue;
4786                 case 'm':
4787                         meter = 1;
4788                         continue;
4789                 case 'n':
4790                         a2x = 0;
4791                         continue;
4792                 case 't':
4793                         list = 1;
4794                         continue;
4795                 case 'v':
4796                         verbose = 1;
4797                         continue;
4798                 case 'V':
4799                         sfprintf(sfstdout, "%s\n", id + 10);
4800                         return 0;
4801                 case '?':
4802                         error(ERROR_USAGE|4, "%s", opt_info.arg);
4803                         continue;
4804                 case ':':
4805                         error(2, "%s", opt_info.arg);
4806                         continue;
4807                 }
4808                 break;
4809         }
4810         if (error_info.errors)
4811                 error(ERROR_USAGE|4, "%s", optusage(NiL));
4812         argv += opt_info.index;
4813 #else
4814         while ((s = *++argv) && *s == '-' && *(s + 1))
4815         {
4816                 if (*(s + 1) == '-')
4817                 {
4818                         if (!*(s + 2))
4819                         {
4820                                 argv++;
4821                                 break;
4822                         }
4823                         usage();
4824                         break;
4825                 }
4826                 for (;;)
4827                 {
4828                         switch (c = *++s)
4829                         {
4830                         case 0:
4831                                 break;
4832                         case 'c':
4833                                 unzip = 1;
4834                                 continue;
4835 #if defined(_SEAR_EXEC) || defined(_SEAR_SEEK)
4836                         case 'i':
4837                                 install = 0;
4838                                 continue;
4839                         case 'k':
4840                                 install = -1;
4841                                 continue;
4842 #endif
4843                         case 'l':
4844                                 local = 1;
4845                                 continue;
4846                         case 'm':
4847                                 meter = 1;
4848                                 continue;
4849                         case 'n':
4850                                 a2x = 0;
4851                                 continue;
4852                         case 't':
4853                                 list = 1;
4854                                 continue;
4855                         case 'v':
4856                                 verbose = 1;
4857                                 continue;
4858                         case 'V':
4859                                 fprintf(stdout, "%s\n", id + 10);
4860                                 return 0;
4861                         default:
4862                                 fprintf(stderr, "%s: -%c: unknown option\n", state.id, c);
4863                                 /*FALLTHROUGH*/
4864                         case '?':
4865                                 usage();
4866                                 break;
4867                         }
4868                         break;
4869                 }
4870         }
4871 #endif
4872
4873 #if defined(_SEAR_SEEK)
4874         if (sear_seek((off_t)_SEAR_SEEK, install && !list))
4875         {
4876                 Sleep(2 * 1000);
4877                 return 1;
4878         }
4879 #endif
4880
4881         /*
4882          * commit on the first gzip magic char
4883          */
4884
4885         if ((c = getchar()) == EOF)
4886                 EXIT(0);
4887         ungetc(c, stdin);
4888         if (c != gz_magic[0])
4889                 gz = 0;
4890         else if (!(gz = gzfopen(stdin, FOPEN_READ)))
4891         {
4892                 fprintf(stderr, "%s: gunzip open error\n", state.id);
4893                 EXIT(1);
4894         }
4895         if (unzip)
4896         {
4897                 if (!gz)
4898                 {
4899                         fprintf(stderr, "%s: not a gzip file\n", state.id);
4900                         EXIT(1);
4901                 }
4902                 while ((c = gzread(gz, buf, sizeof(buf))) > 0)
4903                         if (fwrite(buf, c, 1, stdout) != 1)
4904                         {
4905                                 fprintf(stderr, "%s: write error\n", state.id);
4906                                 EXIT(1);
4907                         }
4908                 if (c < 0)
4909                 {
4910                         fprintf(stderr, "%s: read error\n", state.id);
4911                         EXIT(1);
4912                 }
4913                 if (fflush(stdout))
4914                 {
4915                         fprintf(stderr, "%s: flush error\n", state.id);
4916                         EXIT(1);
4917                 }
4918                 EXIT(0);
4919         }
4920         if (meter)
4921         {
4922                 if ((pos = lseek(0, (off_t)0, SEEK_CUR)) < 0)
4923                         meter = 0;
4924                 else
4925                 {
4926                         if (lseek(0, (off_t)(-4), SEEK_END) < 0 || read(0, num, 4) != 4)
4927                                 meter = 0;
4928                         else if (!(total = ((num[0]|(num[1]<<8)|(num[2]<<16)|(num[3]<<24)) + sizeof(Header_t) - 1) / sizeof(Header_t)))
4929                                 total = 1;
4930                         lseek(0, pos, SEEK_SET);
4931                 }
4932         }
4933
4934         /*
4935          * loop on all the header blocks
4936          */
4937
4938         while (block(stdin, gz, (char*)&header))
4939         {
4940                 /*
4941                  * last 2 blocks are NUL
4942                  */
4943
4944                 if (!*header.name)
4945                         break;
4946
4947                 /*
4948                  * verify the checksum
4949                  */
4950
4951                 s = header.chksum;
4952                 e = header.chksum + sizeof(header.chksum);
4953                 if (a2x)
4954                 {
4955                         for (; s < e; s++)
4956                                 *s = a2x[*(unsigned char*)s];
4957                         s = header.chksum;
4958                 }
4959                 n = number(s) & TAR_SUMASK;
4960                 while (s < e)
4961                         *s++ = 040;
4962                 m = 0;
4963                 s = (char*)&header;
4964                 e = (char*)&header + sizeof(header);
4965                 while (s < e)
4966                         m += *(unsigned char*)s++;
4967                 m &= TAR_SUMASK;
4968                 if (m != n)
4969                 {
4970                         if (state.files)
4971                                 fprintf(stderr, "%s: archive corrupted\n", state.id);
4972                         else
4973                                 fprintf(stderr, "%s: not a tar archive\n", state.id);
4974                         fprintf(stderr, "check sum %lu != %lu\n", m, n);
4975                         EXIT(1);
4976                 }
4977
4978                 /*
4979                  * convert to the native charset
4980                  */
4981
4982                 if (a2x)
4983                         for (e = (s = (char*)&header) + sizeof(header); s < e; s++)
4984                                 *s = a2x[*(unsigned char*)s];
4985
4986                 /*
4987                  * get the pathname, type and size
4988                  */
4989
4990                 state.files++;
4991                 t = path;
4992                 if (!strncmp(header.magic, TMAGIC, sizeof(header.magic)) && *header.prefix)
4993                 {
4994                         s = header.prefix;
4995                         e = header.prefix + sizeof(header.prefix);
4996                         while (s < e && (c = *s++))
4997                                 *t++ = c;
4998                         *t++ = '/';
4999                 }
5000                 s = header.name;
5001                 e = header.name + sizeof(header.name);
5002                 while (s < e && (c = *s++))
5003                         *t++ = c;
5004                 *t = 0;
5005
5006                 /*
5007                  * verify the dir prefix
5008                  */
5009
5010                 t = 0;
5011                 s = path;
5012                 while (*s)
5013                         if (*s++ == '/')
5014                                 t = s;
5015                 if (t)
5016                 {
5017                         *--t = 0;
5018                         if (!list && access(path, 0))
5019                         {
5020                                 s = path;
5021                                 do
5022                                 {
5023                                         if (!(c = *s) || c == '/')
5024                                         {
5025                                                 *s = 0;
5026                                                 if (access(path, 0) && mkdir(path, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH))
5027                                                 {
5028                                                         fprintf(stderr, "%s: %s: cannot create directory\n", state.id, path);
5029                                                         EXIT(1);
5030                                                 }
5031                                                 *s = c;
5032                                         }
5033                                 } while (*s++);
5034                         }
5035                         if (*(t + 1))
5036                                 *t = '/';
5037                         else
5038                                 header.typeflag = DIRTYPE;
5039                 }
5040
5041                 /*
5042                  * check for non-local paths
5043                  */
5044
5045                 if (local && (path[0] == '/' || path[0] == '.' && path[1] == '.' && (!path[2] || path[2] == '/')))
5046                 {
5047                         fprintf(stderr, "%s: %s: non-local path rejected", state.id, path);
5048                         if ((header.typeflag == REGTYPE || header.typeflag == AREGTYPE) && (n = number(header.size)))
5049                                 while (n > 0)
5050                                 {
5051                                         if (!block(stdin, gz, buf))
5052                                         {
5053                                                 fprintf(stderr, "%s: unexpected EOF\n", state.id);
5054                                                 EXIT(1);
5055                                         }
5056                                         if (n <= sizeof(header))
5057                                                 break;
5058                                         n -= sizeof(header);
5059                                 }
5060                         continue;
5061                 }
5062
5063                 /*
5064                  * create and grab the data
5065                  */
5066
5067                 n = number(header.mode);
5068                 mode = 0;
5069                 if (n & TUREAD)
5070                         mode |= S_IRUSR;
5071                 if (n & TUWRITE)
5072                         mode |= S_IWUSR;
5073                 if (n & TUEXEC)
5074                         mode |= S_IXUSR;
5075                 if (n & TGREAD)
5076                         mode |= S_IRGRP;
5077                 if (n & TGWRITE)
5078                         mode |= S_IWGRP;
5079                 if (n & TGEXEC)
5080                         mode |= S_IXGRP;
5081                 if (n & TOREAD)
5082                         mode |= S_IROTH;
5083                 if (n & TOWRITE)
5084                         mode |= S_IWOTH;
5085                 if (n & TOEXEC)
5086                         mode |= S_IXOTH;
5087                 if (list || meter)
5088                 {
5089                         if (meter)
5090                         {
5091                                 int     i;
5092                                 int     j;
5093                                 int     k;
5094                                 int     n;
5095                                 int     p;
5096                                 char    bar[METER_parts + 1];
5097
5098                                 for (s = path; *s; s++)
5099                                         if (s[0] == ' ' && s[1] == '-' && s[2] == '-' && s[3] == ' ')
5100                                                 break;
5101                                 if (*s)
5102                                 {
5103                                         if (clear)
5104                                         {
5105                                                 fprintf(stderr, "%*s", clear, "\r");
5106                                                 clear = 0;
5107                                         }
5108                                         fprintf(stderr, "\n%s\n\n", path);
5109                                 }
5110                                 else
5111                                 {
5112                                         n = (int)strlen(s = path);
5113                                         p = (state.blocks * 100) / total;
5114                                         if (n > (METER_width - METER_parts - 1))
5115                                         {
5116                                                 s += n - (METER_width - METER_parts - 1);
5117                                                 n = METER_width - METER_parts - 1;
5118                                         }
5119                                         j = n + METER_parts + 2;
5120                                         if (!clear)
5121                                                 clear = j + 5;
5122                                         if ((k = clear - j - 5) < 0)
5123                                                 k = 0;
5124                                         if ((i = (p / (100 / METER_parts))) >= sizeof(bar))
5125                                                 i = sizeof(bar) - 1;
5126                                         n = 0;
5127                                         while (n < i)
5128                                                 bar[n++] = '*';
5129                                         while (n < sizeof(bar) - 1)
5130                                                 bar[n++] = ' ';
5131                                         bar[n] = 0;
5132                                         clear = fprintf(stderr, "%02d%% |%s| %s%*s", p, bar, s, k, "\r");
5133                                 }
5134                         }
5135                         else
5136                         {
5137                                 if (verbose)
5138                                 {
5139                                         switch (header.typeflag)
5140                                         {
5141                                         case REGTYPE:
5142                                         case AREGTYPE:
5143                                                 c = '-';
5144                                                 break;
5145                                         case DIRTYPE:
5146                                                 c = 'd';
5147                                                 break;
5148                                         case LNKTYPE:
5149                                                 c = 'h';
5150                                                 break;
5151                                         case SYMTYPE:
5152                                                 c = 'l';
5153                                                 break;
5154                                         default:
5155                                                 c = '?';
5156                                                 break;
5157                                         }
5158                                         printf("%c", c);
5159                                         m = 0400;
5160                                         while (m)
5161                                         {
5162                                                 printf("%c", (n & m) ? 'r' : '-');
5163                                                 m >>= 1;
5164                                                 printf("%c", (n & m) ? 'w' : '-');
5165                                                 m >>= 1;
5166                                                 printf("%c", (n & m) ? 'x' : '-');
5167                                                 m >>= 1;
5168                                         }
5169                                         printf(" %10lu ", number(header.size));
5170                                 }
5171                                 switch (header.typeflag)
5172                                 {
5173                                 case LNKTYPE:
5174                                         printf("%s == %s\n", path, header.linkname);
5175                                         break;
5176                                 case SYMTYPE:
5177                                         printf("%s => %s\n", path, header.linkname);
5178                                         break;
5179                                 default:
5180                                         printf("%s\n", path);
5181                                         break;
5182                                 }
5183                         }
5184                         if (list)
5185                         {
5186                                 if (skip(stdin, gz, buf, number(header.size)))
5187                                         EXIT(1);
5188                                 continue;
5189                         }
5190                 }
5191                 else if (verbose)
5192                         printf("%s\n", path);
5193                 switch (header.typeflag)
5194                 {
5195                 case REGTYPE:
5196                 case AREGTYPE:
5197                         while (!(fp = fopen(path, FOPEN_WRITE)))
5198                                 if (unlink(path))
5199                                 {
5200                                         fprintf(stderr, "%s: warning: %s: cannot create file\n", state.id, path);
5201                                         break;
5202                                 }
5203                         n = number(header.size);
5204                         c = a2x ? 0 : -1;
5205                         while (n > 0)
5206                         {
5207                                 if (!block(stdin, gz, buf))
5208                                 {
5209                                         fprintf(stderr, "%s: unexpected EOF\n", state.id);
5210                                         EXIT(1);
5211                                 }
5212                                 switch (c)
5213                                 {
5214                                 case 0:
5215                                         if ((m = n) < 4)
5216                                         {
5217                                                 for (e = (s = buf) + m; s < e; s++)
5218                                                         if (a2x[*(unsigned char*)s] != '\n')
5219                                                                 break;
5220                                         }
5221                                         else
5222                                         {
5223                                                 if (m > 256)
5224                                                         m = 256;
5225                                                 for (e = (s = buf) + m; s < e; s++)
5226                                                         if (!ascii_text[*(unsigned char*)s])
5227                                                                 break;
5228                                         }
5229                                         if (s < e)
5230                                         {
5231                                                 c = -1;
5232                                                 break;
5233                                         }
5234                                         c = 1;
5235                                         /*FALLTHROUGH*/
5236                                 case 1:
5237                                         for (e = (s = buf) + sizeof(header); s < e; s++)
5238                                                 *s = a2x[*(unsigned char*)s];
5239                                         break;
5240                                 }
5241                                 if (fp && fwrite(buf, n > sizeof(header) ? sizeof(header) : n, 1, fp) != 1)
5242                                 {
5243                                         fprintf(stderr, "%s: %s: write error\n", state.id, path);
5244                                         EXIT(1);
5245                                 }
5246                                 if (n <= sizeof(header))
5247                                         break;
5248                                 n -= sizeof(header);
5249                         }
5250                         if (fp && fclose(fp))
5251                         {
5252                                 fprintf(stderr, "%s: %s: write error\n", state.id, path);
5253                                 EXIT(1);
5254                         }
5255                         break;
5256                 case DIRTYPE:
5257                         if (access(path, 0) && mkdir(path, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH))
5258                         {
5259                                 fprintf(stderr, "%s: %s: cannot create directory\n", state.id, path);
5260                                 EXIT(1);
5261                         }
5262                         break;
5263                 case SYMTYPE:
5264 #if defined(S_IFLNK) || defined(S_ISLNK)
5265                         while (symlink(header.linkname, path))
5266                                 if (unlink(path))
5267                                 {
5268                                         fprintf(stderr, "%s: %s: cannot symlink to %s\n", state.id, path, header.linkname);
5269                                         EXIT(1);
5270                                 }
5271                         continue;
5272 #endif
5273 #if !_WIN32 || _WINIX
5274                 case LNKTYPE:
5275                         while (link(header.linkname, path))
5276                                 if (unlink(path))
5277                                 {
5278                                         fprintf(stderr, "%s: %s: cannot link to %s\n", state.id, path, header.linkname);
5279                                         EXIT(1);
5280                                 }
5281                         continue;
5282 #endif
5283                 default:
5284                         fprintf(stderr, "%s: %s: file type %c ignored\n", state.id, path, header.typeflag);
5285                         if (skip(stdin, gz, buf, number(header.size)))
5286                                 EXIT(1);
5287                         continue;
5288                 }
5289                 if (chmod(path, mode))
5290                         fprintf(stderr, "%s: %s: cannot change mode to %03o\n", state.id, path, mode);
5291         }
5292         if (clear)
5293                 fprintf(stderr, "%*s", clear, "\r");
5294         if (!state.files)
5295                 fprintf(stderr, "%s: warning: empty archive\n", state.id);
5296         else if (verbose)
5297                 fprintf(stderr, "%lu file%s, %lu block%s\n", state.files, state.files == 1 ? "" : "s", state.blocks, state.blocks == 1 ? "" : "s");
5298 #if defined(_SEAR_EXEC)
5299 #if !defined(_SEAR_ARGS)
5300 #define _SEAR_ARGS      0
5301 #endif
5302         if (install && sear_exec(_SEAR_EXEC, argv, _SEAR_ARGS, install))
5303         {
5304                 Sleep(2 * 1000);
5305                 return 1;
5306         }
5307 #endif
5308         return 0;
5309 }
5310
5311 #endif /* _RATZ_C */