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
zmemcpy(dest,source,len)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
zmemcmp(s1,s2,len)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
zmemzero(dest,len)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
zcalloc(voidpf opaque,unsigned items,unsigned size)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
zcfree(voidpf opaque,voidpf ptr)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
zcalloc(voidpf opaque,unsigned items,unsigned size)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
zcfree(voidpf opaque,voidpf ptr)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
zcalloc(opaque,items,size)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
zcfree(opaque,ptr)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 /* ========================================================================= */
crc32(crc,buf,len)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 /* ========================================================================= */
adler32(adler,buf,len)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 */
inflate_table(type,lens,codes,table,bits,work)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 */
inflate_fast(strm,start)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
inflateReset(strm)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
inflatePrime(strm,bits,value)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
inflateInit2_(strm,windowBits,version,stream_size)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
inflateInit_(strm,version,stream_size)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 */
fixedtables(state)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 */
updatewindow(strm,out)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
inflate(strm,flush)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
inflateEnd(strm)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
inflateSetDictionary(strm,dictionary,dictLength)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
inflateGetHeader(strm,head)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 */
syncsearch(have,buf,len)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
inflateSync(strm)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 */
inflateSyncPoint(strm)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
inflateCopy(dest,source)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 */
gz_open(path,mode,fp)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 */
gzfopen(fp,mode)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 */
get_byte(s)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 */
check_header(s)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 */
destroy(s)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 */
gzread(file,buf,len)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 */
getLong(s)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
usage()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
block(fp,gz,buf)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
skip(fp,gz,buf,n)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
number(s)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
sear_seek(off_t offset,int tmp)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
sear_rm_r(char * dir)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
sear_system(const char * command,int nowindow)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*
copy(char * t,const char * f,char * e)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
sear_exec(const char * cmd,char * const * arg,char * operands,int code)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
main(argc,argv)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 */
5312