home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / progc / unzip_c.arj / UNZIP.C < prev    next >
C/C++ Source or Header  |  1990-03-18  |  39KB  |  1,710 lines
  1.  
  2. /*
  3.  * Copyright 1989 Samuel H. Smith;  All rights reserved
  4.  *
  5.  * Do not distribute modified versions without my permission.
  6.  * Do not remove or alter this notice or any other copyright notice.
  7.  * If you use this in your own program you must distribute source code.
  8.  * Do not use any of this in a commercial product.
  9.  *
  10.  */
  11.  
  12. /*
  13.  * UnZip - A simple zipfile extract utility
  14.  *
  15.  * To compile:
  16.  *      tcc -B -O -Z -G -mc unzip.c        ;turbo C 2.0, compact model
  17.  *
  18.  * Compile-time definitions:
  19.  *    HIGH_LOW    target machine is big-endian (68000 family)
  20.  *    ASM        critical functions are written in assembler
  21.  *    void=int    for compilers that don't implement void
  22.  *    UNIX        target o.s. is UNIX
  23.  *    BSD        UNIX is BSD
  24.  *    V7        UNIX is Version 7
  25.  *
  26.  * REVISION HISTORY
  27.  *
  28.  * 12/14/89  C. Mascott  2.0a    adapt for UNIX
  29.  *                ifdef HIGH_LOW swap bytes in time, date, CRC,
  30.  *                  version needed, bit flag
  31.  *                implement true s-f trees instead of table
  32.  *                don't pre-allocate output file space
  33.  *                implement -t, -v, member file specs
  34.  *                buffer all input
  35.  *                change hsize_array_integer to short
  36.  *                overlap storage used by different comp. methods
  37.  *                speed up unImplode
  38.  *                use insertion sort in SortLengths
  39.  *                define zipfile header structs in a way that
  40.  *                  avoids structure padding on 32-bit machines
  41.  *                fix "Bad CRC" msg: good/bad CRCs were swapped
  42.  *                check for write error on output file
  43.  *                added by John Cowan <cowan@magpie.masa.com>:
  44.  *                support -c option to expand to console
  45.  *                use stderr for messages
  46.  *                allow lowercase component name specs
  47.  *
  48.  */
  49.  
  50. #define VERSION  "UnZip:  Zipfile Extract v2.0a (C) of 12-14-89;  (C) 1989 Samuel H. Smith"
  51.  
  52. typedef unsigned char byte;    /* code assumes UNSIGNED bytes */
  53. typedef long longint;
  54. typedef unsigned short word;
  55. typedef char boolean;
  56.  
  57. #define STRSIZ 256
  58.  
  59. #include <stdio.h>
  60.  /* this is your standard header for all C compiles */
  61. #include <ctype.h>
  62.  
  63. #ifdef __STDC__
  64.  
  65. #include <stdlib.h>
  66.  /* this include defines various standard library prototypes */
  67.  
  68. #else
  69.  
  70. char *malloc();
  71.  
  72. #endif
  73.  
  74. #define min(a,b) ((a) < (b) ? (a) : (b))
  75.  
  76. /*
  77.  * SEE HOST OPERATING SYSTEM SPECIFICS SECTION STARTING NEAR LINE 180
  78.  *
  79.  */
  80.  
  81.  
  82. /* ----------------------------------------------------------- */
  83. /*
  84.  * Zipfile layout declarations
  85.  *
  86.  */
  87.  
  88. /* Macros for accessing the longint header fields.  These fields
  89.    are defined as array of char to prevent a 32-bit compiler from
  90.    padding the struct so that longints start on a 4-byte boundary.
  91.    This will not work on a machine that can access longints only
  92.    if they start on a 4-byte boundary. */
  93.  
  94. #define LONGIP(l) ((longint *) &((l)[0]))
  95. #define LONGI(l) (*(LONGIP(l)))
  96.  
  97. typedef longint signature_type;
  98.  
  99.  
  100. #define LOCAL_FILE_HEADER_SIGNATURE  0x04034b50L
  101.  
  102.  
  103. typedef struct local_file_header {
  104.     word version_needed_to_extract;
  105.         word general_purpose_bit_flag;
  106.     word compression_method;
  107.     word last_mod_file_time;
  108.     word last_mod_file_date;
  109.     byte crc32[4];
  110.     byte compressed_size[4];
  111.         byte uncompressed_size[4];
  112.     word filename_length;
  113.     word extra_field_length;
  114. } local_file_header;
  115.  
  116.  
  117. #define CENTRAL_FILE_HEADER_SIGNATURE  0x02014b50L
  118.  
  119.  
  120. typedef struct central_directory_file_header {
  121.     word version_made_by;
  122.     word version_needed_to_extract;
  123.     word general_purpose_bit_flag;
  124.     word compression_method;
  125.     word last_mod_file_time;
  126.     word last_mod_file_date;
  127.     byte crc32[4];
  128.     byte compressed_size[4];
  129.     byte uncompressed_size[4];
  130.     word filename_length;
  131.     word extra_field_length;
  132.     word file_comment_length;
  133.     word disk_number_start;
  134.     word internal_file_attributes;
  135.     byte external_file_attributes[4];
  136.     byte relative_offset_local_header[4];
  137. } central_directory_file_header;
  138.  
  139.  
  140. #define END_CENTRAL_DIR_SIGNATURE  0x06054b50L
  141.  
  142.  
  143. typedef struct end_central_dir_record {
  144.     word number_this_disk;
  145.     word number_disk_with_start_central_directory;
  146.     word total_entries_central_dir_on_this_disk;
  147.     word total_entries_central_dir;
  148.     byte size_central_directory[4];
  149.     byte offset_start_central_directory[4];
  150.     word zipfile_comment_length;
  151. } end_central_dir_record;
  152.  
  153.  
  154. char *fnames[2] = {    /* default filenames vector */
  155.     "*",
  156.     NULL
  157. };
  158. char **fnv = &fnames[0];
  159.  
  160. int tflag;        /* -t: test */
  161. int vflag;        /* -v: view directory */
  162. int cflag;        /* -c: output to stdout (JC) */
  163.  
  164. int members;
  165. longint csize;
  166. longint ucsize;
  167. longint tot_csize;
  168. longint tot_ucsize;
  169.  
  170.  
  171. /* ----------------------------------------------------------- */
  172. /*
  173.  * input file variables
  174.  *
  175.  */
  176.  
  177. #define INBUFSIZ BUFSIZ        /* same as stdio uses */
  178. byte *inbuf;            /* input file buffer - any size is legal */
  179. byte *inptr;
  180.  
  181. int incnt;
  182. word bitbuf;
  183. int bits_left;
  184. boolean zipeof;
  185.  
  186. int zipfd;
  187. char zipfn[STRSIZ];
  188. local_file_header lrec;
  189.  
  190.  
  191. /* ----------------------------------------------------------- */
  192. /*
  193.  * output stream variables
  194.  *
  195.  */
  196.  
  197. #define OUTBUFSIZ 0x2000        /* unImplode needs power of 2, >= 0x2000 */
  198. byte *outbuf;                   /* buffer for rle look-back */
  199. byte *outptr;
  200.  
  201. longint outpos;            /* absolute position in outfile */
  202. int outcnt;            /* current position in outbuf */
  203.  
  204. int outfd;
  205. char filename[STRSIZ];
  206. char extra[STRSIZ];
  207.  
  208. #define DLE 144
  209.  
  210.  
  211. /* ----------------------------------------------------------- */
  212. /*
  213.  * shrink/reduce working storage
  214.  *
  215.  */
  216.  
  217. int factor;
  218. /* really need only 256, but prefix_of, which shares the same
  219.    storage, is just over 16K */
  220. byte followers[257][64];    /* also lzw prefix_of, s-f lit_nodes */
  221. byte Slen[256];
  222.  
  223. #define max_bits 13
  224. #define init_bits 9
  225. #define hsize 8192
  226. #define first_ent 257
  227. #define clear 256
  228.  
  229. typedef short hsize_array_integer[hsize+1];    /* was used for prefix_of */
  230. typedef byte hsize_array_byte[hsize+1];
  231.  
  232. short *prefix_of = (short *) followers;    /* share reduce/shrink storage */
  233. hsize_array_byte suffix_of;        /* also s-f length_nodes */
  234. hsize_array_byte stack;            /* also s-f distance_nodes */
  235.  
  236. int codesize;
  237. int maxcode;
  238. int free_ent;
  239. int maxcodemax;
  240. int offset;
  241. int sizex;
  242.  
  243.  
  244.  
  245. /* ============================================================= */
  246. /*
  247.  * Host operating system details
  248.  *
  249.  */
  250.  
  251. #ifdef UNIX
  252.  
  253. /* On some systems the contents of sys/param.h duplicates the
  254.    contents of sys/types.h, so you don't need (and can't use)
  255.    sys/types.h. */
  256.  
  257. #include <sys/types.h>
  258. #include <sys/param.h>
  259. #include <time.h>
  260. struct tm *gmtime(), *localtime();
  261. #define ZSUFX ".zip"
  262.  
  263. #else
  264.  
  265. #define BSIZE 512    /* disk block size */
  266. #define ZSUFX ".ZIP"
  267.  
  268. #endif
  269.  
  270. #if defined(V7) || defined(BSD)
  271.  
  272. #define strchr index
  273. #define strrchr rindex
  274.  
  275. #endif
  276.  
  277. #ifdef __STDC__
  278.  
  279. #include <string.h>
  280.  /* this include defines strcpy, strcmp, etc. */
  281.  
  282. #else
  283.  
  284. char *strchr(), *strrchr();
  285.  
  286. #endif
  287.  
  288. long lseek();
  289.  
  290. #define SEEK_SET  0
  291. #define SEEK_CUR  1
  292. #define SEEK_END  2
  293.  
  294. #ifdef V7
  295.  
  296. #define O_RDONLY  0
  297. #define O_WRONLY  1
  298. #define O_RDWR    2
  299.  
  300. #else
  301.  
  302. #include <fcntl.h>
  303.  /*
  304.   * this include file defines
  305.   *             #define O_BINARY 0x8000  (* no cr-lf translation *)
  306.   * as used in the open() standard function
  307.   */
  308.  
  309. #endif
  310.  
  311. #ifndef UNIX
  312.  
  313. #include <sys/stat.h>
  314.  /*
  315.   * this include file defines
  316.   *             #define S_IREAD 0x0100  (* owner may read *)
  317.   *             #define S_IWRITE 0x0080 (* owner may write *)
  318.   * as used in the creat() standard function
  319.   */
  320.  
  321. #endif
  322.  
  323. void set_file_time()
  324.  /*
  325.   * set the output file date/time stamp according to information from the
  326.   * zipfile directory record for this file 
  327.   */
  328. {
  329. #ifndef UNIX
  330.     union {
  331.                 struct ftime ft;        /* system file time record */
  332.         struct {
  333.                         word ztime;     /* date and time words */
  334.                         word zdate;     /* .. same format as in .ZIP file */
  335.         } zt;
  336.     } td;
  337.  
  338.     /*
  339.      * set output file date and time - this is optional and can be
  340.      * deleted if your compiler does not easily support setftime() 
  341.      */
  342.  
  343.     td.zt.ztime = lrec.last_mod_file_time;
  344.     td.zt.zdate = lrec.last_mod_file_date;
  345.  
  346.     setftime(outfd, &td.ft);
  347.  
  348. #else
  349.  
  350.     time_t times[2];
  351.     struct tm *tmbuf;
  352.     long m_time;
  353.     int yr, mo, dy, hh, mm, ss, leap, days = 0;
  354.  
  355.     /*
  356.      * These date conversions look a little wierd, so I'll explain.
  357.      * UNIX bases all file modification times on the number of seconds
  358.      * elapsed since Jan 1, 1970, 00:00:00 GMT.  Therefore, to maintain
  359.      * compatibility with MS-DOS archives, which date from Jan 1, 1980,
  360.      * with NO relation to GMT, the following conversions must be made:
  361.      *         the Year (yr) must be incremented by 10;
  362.      *        the Date (dy) must be decremented by 1;
  363.      *        and the whole mess must be adjusted by TWO factors:
  364.      *            relationship to GMT (ie.,Pacific Time adds 8 hrs.),
  365.      *            and whether or not it is Daylight Savings Time.
  366.      * Also, the usual conversions must take place to account for leap years,
  367.      * etc.
  368.      *                                     C. Seaman
  369.      */
  370.  
  371.     yr = (((lrec.last_mod_file_date >> 9) & 0x7f) + 10);  /* dissect date */
  372.     mo = ((lrec.last_mod_file_date >> 5) & 0x0f);
  373.     dy = ((lrec.last_mod_file_date & 0x1f) - 1);
  374.  
  375.     hh = ((lrec.last_mod_file_time >> 11) & 0x1f);        /* dissect time */
  376.     mm = ((lrec.last_mod_file_time >> 5) & 0x3f);
  377.     ss = ((lrec.last_mod_file_time & 0x1f) * 2);
  378.  
  379.     /* leap = # of leap years from 1970 up to but not including
  380.        the current year */
  381.  
  382.     leap = ((yr+1969)/4);              /* Leap year base factor */
  383.  
  384.     /* How many days from 1970 to this year? */
  385.     days = (yr * 365) + (leap - 492);
  386.  
  387.     switch(mo)                   /* calculate expired days this year */
  388.     {
  389.     case 12:
  390.         days += 30;
  391.     case 11:
  392.         days += 31;
  393.     case 10:
  394.         days += 30;
  395.     case 9:
  396.         days += 31;
  397.     case 8:
  398.         days += 31;
  399.     case 7:
  400.         days += 30;
  401.     case 6:
  402.         days += 31;
  403.     case 5:
  404.         days += 30;
  405.     case 4:
  406.         days += 31;
  407.     case 3:
  408.         days += 28;                    /* account for leap years */
  409.         if (((yr+1970) % 4 == 0) && (yr+1970) != 2000)
  410.             ++days;
  411.     case 2:
  412.         days += 31;
  413.     }
  414.  
  415.     /* convert date & time to seconds relative to 00:00:00, 01/01/1970 */
  416.     m_time = ((days + dy) * 86400) + (hh * 3600) + (mm * 60) + ss;
  417.  
  418. #ifdef BSD
  419.     struct timeval tv;
  420.     struct timezone tz;
  421.  
  422.     gettimeofday(&tv, &tz);
  423.  
  424.     if (tz.tz_dsttime != 0)
  425.         m_time -= 3600;
  426.  
  427.     m_time += tz.tz_minuteswest * 60;  /* account for timezone differences */
  428. #else
  429.     tmbuf = localtime(&m_time);
  430.     hh = tmbuf->tm_hour;
  431.     tmbuf = gmtime(&m_time);
  432.     hh = tmbuf->tm_hour - hh;
  433.     if (hh < 0)
  434.     hh += 24;
  435.     m_time += (hh * 3600);             /* account for timezone differences */
  436. #endif
  437.  
  438.     times[0] = m_time;             /* set the stamp on the file */
  439.     times[1] = m_time;
  440.     utime(filename, times);
  441. #endif
  442. }
  443.  
  444.  
  445. int create_output_file()
  446.  /* return non-0 if creat failed */
  447. {    /* create the output file with READ and WRITE permissions */
  448.     if (cflag) {        /* output to stdout (a copy of it, really) */
  449.         outfd = dup(1);
  450.         return 0;
  451.         }
  452. #ifndef UNIX
  453.     outfd = creat(filename, S_IWRITE | S_IREAD);
  454. #else
  455.     outfd = creat(filename, 0666);    /* let umask strip unwanted perm's */
  456. #endif
  457.  
  458.     if (outfd < 1) {
  459.         fprintf(stderr, "Can't create output: %s\n", filename);
  460.         return 1;
  461.     }
  462.  
  463.     /*
  464.      * close the newly created file and reopen it in BINARY mode to
  465.      * disable all CR/LF translations 
  466.      */
  467. #ifndef UNIX
  468.     close(outfd);
  469.     outfd = open(filename, O_RDWR | O_BINARY);
  470. #endif
  471.     return 0;
  472. }
  473.  
  474.  
  475. int open_input_file()
  476.  /* return non-0 if open failed */
  477. {
  478.     /*
  479.      * open the zipfile for reading and in BINARY mode to prevent cr/lf
  480.      * translation, which would corrupt the bitstreams 
  481.      */
  482.  
  483. #ifndef UNIX
  484.     zipfd = open(zipfn, O_RDONLY | O_BINARY);
  485. #else
  486.     zipfd = open(zipfn, O_RDONLY);
  487. #endif
  488.     if (zipfd < 1) {
  489.         fprintf(stderr, "Can't open input file: %s\n", zipfn);
  490.         return (1);
  491.     }
  492.     return 0;
  493. }
  494.  
  495.  
  496. #ifdef HIGH_LOW
  497.  
  498. void swap_bytes(wordp)
  499. word *wordp;
  500.  /* convert intel style 'short int' variable to host format */
  501. {
  502.     char *charp = (char *) wordp;
  503.     char temp;
  504.  
  505.     temp = charp[0];
  506.     charp[0] = charp[1];
  507.     charp[1] = temp;
  508. }
  509.  
  510. void swap_lbytes(longp)
  511. longint *longp;
  512.  /* convert intel style 'long' variable to host format */
  513. {
  514.     char *charp = (char *) longp;
  515.     char temp[4];
  516.  
  517.     temp[3] = charp[0];
  518.     temp[2] = charp[1];
  519.     temp[1] = charp[2];
  520.     temp[0] = charp[3];
  521.  
  522.     charp[0] = temp[0];
  523.     charp[1] = temp[1];
  524.     charp[2] = temp[2];
  525.     charp[3] = temp[3];
  526. }
  527.  
  528. #endif
  529.  
  530.  
  531.  
  532. /* ============================================================= */
  533.  
  534. int readbuf(fd, buf, size)
  535. int fd;
  536. char *buf;
  537. register unsigned size;
  538. {
  539.     register int count;
  540.     int n;
  541.  
  542.     n = size;
  543.     while (size)  {
  544.         if (incnt == 0)  {
  545.             if ((incnt = read(fd, inbuf, INBUFSIZ)) <= 0)
  546.                 return(incnt);
  547.             inptr = inbuf;
  548.         }
  549.         count = min(size, incnt);
  550.         memcpy(buf, inptr, count);
  551.         buf += count;
  552.         inptr += count;
  553.         incnt -= count;
  554.         size -= count;
  555.     }
  556.     return(n);
  557. }
  558.  
  559. int ReadByte(x)
  560. word *x;
  561.  /* read a byte; return 8 if byte available, 0 if not */
  562. {
  563.     if (csize-- <= 0)
  564.         return 0;
  565.     if (incnt == 0)  {
  566.         if ((incnt = read(zipfd, inbuf, INBUFSIZ)) <= 0)
  567.             return 0;
  568.         inptr = inbuf;
  569.     }
  570.     *x = *inptr++;
  571.     --incnt;
  572.     return 8;
  573. }
  574.  
  575.  
  576. /* ------------------------------------------------------------- */
  577. static word mask_bits[] =
  578.         {0,     0x0001, 0x0003, 0x0007, 0x000f,
  579.                 0x001f, 0x003f, 0x007f, 0x00ff,
  580.                 0x01ff, 0x03ff, 0x07ff, 0x0fff,
  581.                 0x1fff, 0x3fff, 0x7fff, 0xffff
  582.         };
  583.  
  584.  
  585. int FillBitBuffer(bits)
  586. register int bits;
  587. {
  588.     /* get the bits that are left and read the next word */
  589.         register int result = bitbuf;
  590.     word temp;
  591.     int sbits = bits_left;
  592.     bits -= bits_left;
  593.  
  594.     /* read next word of input */
  595.     bits_left = ReadByte(&bitbuf);
  596.     bits_left += ReadByte(&temp);
  597.     bitbuf |= (temp << 8);
  598.     if (bits_left == 0)
  599.         zipeof = 1;
  600.  
  601.     /* get the remaining bits */
  602.         result = result | (int) ((bitbuf & mask_bits[bits]) << sbits);
  603.         bitbuf >>= bits;
  604.         bits_left -= bits;
  605.         return result;
  606. }
  607.  
  608. #define READBIT(nbits,zdest) { if (nbits <= bits_left) { zdest = (int)(bitbuf & mask_bits[nbits]); bitbuf >>= nbits; bits_left -= nbits; } else zdest = FillBitBuffer(nbits);}
  609.  
  610. /*
  611.  * macro READBIT(nbits,zdest)
  612.  *  {
  613.  *      if (nbits <= bits_left) {
  614.  *          zdest = (int)(bitbuf & mask_bits[nbits]);
  615.  *          bitbuf >>= nbits;
  616.  *          bits_left -= nbits;
  617.  *      } else
  618.  *          zdest = FillBitBuffer(nbits);
  619.  *  }
  620.  *
  621.  */
  622.  
  623.  
  624. /* ------------------------------------------------------------- */
  625.  
  626. #include "crc32.h"
  627.  
  628.  
  629. /* ------------------------------------------------------------- */
  630.  
  631. void FlushOutput()
  632.  /* flush contents of output buffer */
  633. {
  634.     UpdateCRC(outbuf, outcnt);
  635.     if (!tflag)
  636.         if (write(outfd, outbuf, outcnt) != outcnt)  {
  637.             fprintf(stderr, " File write error\n");
  638.             exit(1);
  639.         }
  640.     outpos += outcnt;
  641.     outcnt = 0;
  642.     outptr = outbuf;
  643. }
  644.  
  645. #define OUTB(intc) { *outptr++=intc; if (++outcnt==OUTBUFSIZ) FlushOutput(); }
  646.  
  647. /*
  648.  *  macro OUTB(intc)
  649.  *  {
  650.  *      *outptr++=intc;
  651.  *      if (++outcnt==OUTBUFSIZ)
  652.  *          FlushOutput();
  653.  *  }
  654.  *
  655.  */
  656.  
  657.  
  658. /* ----------------------------------------------------------- */
  659.  
  660. void LoadFollowers()
  661. {
  662.         register int x;
  663.         register int i;
  664.  
  665.     for (x = 255; x >= 0; x--) {
  666.                 READBIT(6,Slen[x]);
  667.         for (i = 0; i < Slen[x]; i++) {
  668.                         READBIT(8,followers[x][i]);
  669.         }
  670.     }
  671. }
  672.  
  673.  
  674. /* ----------------------------------------------------------- */
  675. /*
  676.  * The Reducing algorithm is actually a combination of two
  677.  * distinct algorithms.  The first algorithm compresses repeated
  678.  * byte sequences, and the second algorithm takes the compressed
  679.  * stream from the first algorithm and applies a probabilistic
  680.  * compression method.
  681.  */
  682.  
  683. int L_table[] = {0, 0x7f, 0x3f, 0x1f, 0x0f};
  684.  
  685. int D_shift[] = {0, 0x07, 0x06, 0x05, 0x04};
  686. int D_mask[]  = {0, 0x01, 0x03, 0x07, 0x0f};
  687.  
  688. int B_table[] = {8, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5,
  689.          5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6,
  690.          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  691.          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
  692.          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  693.          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  694.          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  695.          7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  696.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  697.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  698.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  699.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  700.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  701.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  702.          8, 8, 8, 8};
  703.  
  704. /* ----------------------------------------------------------- */
  705.  
  706. void unReduce()
  707.  /* expand probablisticly reduced data */
  708. {
  709.         register int lchar;
  710.         int nchar;
  711.         int ExState;
  712.         int V;
  713.         int Len;
  714.  
  715.         factor = lrec.compression_method - 1;
  716.     ExState = 0;
  717.     lchar = 0;
  718.     LoadFollowers();
  719.  
  720.         while (((outpos+outcnt) < ucsize) && (!zipeof)) {
  721.         if (Slen[lchar] == 0)
  722.                         READBIT(8,nchar)      /* ; */
  723.                 else
  724.         {
  725.                         READBIT(1,nchar);
  726.                         if (nchar != 0)
  727.                                 READBIT(8,nchar)      /* ; */
  728.                         else
  729.             {
  730.                                 int follower;
  731.                                 int bitsneeded = B_table[Slen[lchar]];
  732.                                 READBIT(bitsneeded,follower);
  733.                                 nchar = followers[lchar][follower];
  734.             }
  735.         }
  736.  
  737.         /* expand the resulting byte */
  738.         switch (ExState) {
  739.  
  740.         case 0:
  741.                         if (nchar != DLE)
  742.                                 OUTB(nchar) /*;*/
  743.             else
  744.                 ExState = 1;
  745.             break;
  746.  
  747.         case 1:
  748.                         if (nchar != 0) {
  749.                                 V = nchar;
  750.                 Len = V & L_table[factor];
  751.                 if (Len == L_table[factor])
  752.                     ExState = 2;
  753.                 else
  754.                     ExState = 3;
  755.             }
  756.             else {
  757.                                 OUTB(DLE);
  758.                 ExState = 0;
  759.             }
  760.             break;
  761.  
  762.                 case 2: {
  763.                                 Len += nchar;
  764.                 ExState = 3;
  765.             }
  766.             break;
  767.  
  768.                 case 3: {
  769.                 register int i = Len + 3;
  770.                 int offset = (((V >> D_shift[factor]) &
  771.                                           D_mask[factor]) << 8) + nchar + 1;
  772.                                 longint op = (outpos+outcnt) - offset;
  773.  
  774.                 /* special case- before start of file */
  775.                 while ((op < 0L) && (i > 0)) {
  776.                     OUTB(0);
  777.                     op++;
  778.                     i--;
  779.                 }
  780.  
  781.                 /* normal copy of data from output buffer */
  782.                 {
  783.                     register int ix = (int) (op % OUTBUFSIZ);
  784.  
  785.                                         /* do a block memory copy if possible */
  786.                                         if ( ((ix    +i) < OUTBUFSIZ) &&
  787.                                              ((outcnt+i) < OUTBUFSIZ) ) {
  788.                                                 memcpy(outptr,&outbuf[ix],i);
  789.                                                 outptr += i;
  790.                                                 outcnt += i;
  791.                                         }
  792.  
  793.                                         /* otherwise copy byte by byte */
  794.                                         else while (i--) {
  795.                                                 OUTB(outbuf[ix]);
  796.                                                 if (++ix >= OUTBUFSIZ)
  797.                                                         ix = 0;
  798.                                         }
  799.                                 }
  800.  
  801.                 ExState = 0;
  802.             }
  803.             break;
  804.         }
  805.  
  806.                 /* store character for next iteration */
  807.                 lchar = nchar;
  808.         }
  809. }
  810.  
  811.  
  812. /* ------------------------------------------------------------- */
  813. /*
  814.  * Shrinking is a Dynamic Ziv-Lempel-Welch compression algorithm
  815.  * with partial clearing.
  816.  *
  817.  */
  818.  
  819. void partial_clear()
  820. {
  821.         register int pr;
  822.         register int cd;
  823.  
  824.     /* mark all nodes as potentially unused */
  825.     for (cd = first_ent; cd < free_ent; cd++)
  826.         prefix_of[cd] |= 0x8000;
  827.  
  828.     /* unmark those that are used by other nodes */
  829.     for (cd = first_ent; cd < free_ent; cd++) {
  830.         pr = prefix_of[cd] & 0x7fff;    /* reference to another node? */
  831.                 if (pr >= first_ent)            /* flag node as referenced */
  832.             prefix_of[pr] &= 0x7fff;
  833.     }
  834.  
  835.     /* clear the ones that are still marked */
  836.     for (cd = first_ent; cd < free_ent; cd++)
  837.         if ((prefix_of[cd] & 0x8000) != 0)
  838.             prefix_of[cd] = -1;
  839.  
  840.     /* find first cleared node as next free_ent */
  841.         cd = first_ent;
  842.         while ((cd < maxcodemax) && (prefix_of[cd] != -1))
  843.                 cd++;
  844.         free_ent = cd;
  845. }
  846.  
  847.  
  848. /* ------------------------------------------------------------- */
  849.  
  850. void unShrink()
  851. {
  852. #define  GetCode(dest) READBIT(codesize,dest)
  853.  
  854.     register int code;
  855.     register int stackp;
  856.     int finchar;
  857.     int oldcode;
  858.     int incode;
  859.  
  860.  
  861.     /* decompress the file */
  862.     maxcodemax = 1 << max_bits;
  863.     codesize = init_bits;
  864.     maxcode = (1 << codesize) - 1;
  865.     free_ent = first_ent;
  866.     offset = 0;
  867.     sizex = 0;
  868.  
  869.     for (code = maxcodemax; code > 255; code--)
  870.         prefix_of[code] = -1;
  871.  
  872.     for (code = 255; code >= 0; code--) {
  873.         prefix_of[code] = 0;
  874.         suffix_of[code] = code;
  875.     }
  876.  
  877.     GetCode(oldcode);
  878.     if (zipeof)
  879.         return;
  880.     finchar = oldcode;
  881.  
  882.         OUTB(finchar);
  883.  
  884.         stackp = hsize;
  885.  
  886.     while (!zipeof) {
  887.         GetCode(code);
  888.         if (zipeof)
  889.             return;
  890.  
  891.         while (code == clear) {
  892.             GetCode(code);
  893.             switch (code) {
  894.  
  895.             case 1:{
  896.                     codesize++;
  897.                     if (codesize == max_bits)
  898.                         maxcode = maxcodemax;
  899.                     else
  900.                         maxcode = (1 << codesize) - 1;
  901.                 }
  902.                 break;
  903.  
  904.             case 2:
  905.                 partial_clear();
  906.                 break;
  907.             }
  908.  
  909.             GetCode(code);
  910.             if (zipeof)
  911.                 return;
  912.         }
  913.  
  914.  
  915.         /* special case for KwKwK string */
  916.         incode = code;
  917.         if (prefix_of[code] == -1) {
  918.                         stack[--stackp] = finchar;
  919.             code = oldcode;
  920.         }
  921.  
  922.  
  923.         /* generate output characters in reverse order */
  924.         while (code >= first_ent) {
  925.                         stack[--stackp] = suffix_of[code];
  926.             code = prefix_of[code];
  927.         }
  928.  
  929.         finchar = suffix_of[code];
  930.                 stack[--stackp] = finchar;
  931.  
  932.  
  933.                 /* and put them out in forward order, block copy */
  934.                 if ((hsize-stackp+outcnt) < OUTBUFSIZ) {
  935.                         memcpy(outptr,&stack[stackp],hsize-stackp);
  936.                         outptr += hsize-stackp;
  937.                         outcnt += hsize-stackp;
  938.                         stackp = hsize;
  939.                 }
  940.  
  941.                 /* output byte by byte if we can't go by blocks */
  942.                 else while (stackp < hsize)
  943.                         OUTB(stack[stackp++]);
  944.  
  945.  
  946.         /* generate new entry */
  947.         code = free_ent;
  948.         if (code < maxcodemax) {
  949.             prefix_of[code] = oldcode;
  950.             suffix_of[code] = finchar;
  951.  
  952.             do
  953.                 code++;
  954.             while ((code < maxcodemax) && (prefix_of[code] != -1));
  955.  
  956.             free_ent = code;
  957.         }
  958.  
  959.         /* remember previous code */
  960.         oldcode = incode;
  961.     }
  962.  
  963. }
  964.  
  965.  
  966. /* ------------------------------------------------------------- */ 
  967. /*
  968.  * Imploding
  969.  * ---------
  970.  *
  971.  * The Imploding algorithm is actually a combination of two distinct
  972.  * algorithms.  The first algorithm compresses repeated byte sequences
  973.  * using a sliding dictionary.  The second algorithm is used to compress
  974.  * the encoding of the sliding dictionary ouput, using multiple
  975.  * Shannon-Fano trees.
  976.  *
  977.  */ 
  978.  
  979. #define LITVALS        256
  980. #define DISTVALS    64
  981. #define LENVALS        64
  982. #define MAXSF        LITVALS
  983.  
  984.    typedef struct sf_entry { 
  985.                  byte         Value; 
  986.                  byte         BitLength; 
  987.               } sf_entry; 
  988.  
  989.    typedef struct sf_tree {   /* a shannon-fano "tree" (table) */
  990.       sf_entry     entry[MAXSF];
  991.       int          entries;
  992.       int          MaxLength;
  993.    } sf_tree; 
  994.  
  995.    typedef sf_tree      *sf_treep; 
  996.  
  997.    typedef struct sf_node {   /* node in a true shannon-fano tree */
  998.       word         left;    /* 0 means leaf node */
  999.       word         right;    /* or value if leaf node */
  1000.    } sf_node;
  1001.  
  1002.    sf_tree      lit_tree; 
  1003.    sf_tree      length_tree; 
  1004.    sf_tree      distance_tree; 
  1005.    /* s-f storage is shared with that used by other comp. methods */
  1006.    sf_node    *lit_nodes = (sf_node *) followers;    /* 2*LITVALS nodes */
  1007.    sf_node    *length_nodes = (sf_node *) suffix_of;    /* 2*LENVALS nodes */
  1008.    sf_node    *distance_nodes = (sf_node *) stack;    /* 2*DISTVALS nodes */
  1009.    boolean      lit_tree_present; 
  1010.    boolean      eightK_dictionary; 
  1011.    int          minimum_match_length;
  1012.    int          dict_bits;
  1013.  
  1014.  
  1015. void         SortLengths(tree)
  1016. sf_tree *tree;
  1017.   /* Sort the Bit Lengths in ascending order, while retaining the order
  1018.     of the original lengths stored in the file */ 
  1019. { 
  1020.     register sf_entry *ejm1;    /* entry[j - 1] */
  1021.     register int j;
  1022.     register sf_entry *entry;
  1023.     register int i;
  1024.     sf_entry tmp;
  1025.     int entries;
  1026.     unsigned a, b;
  1027.  
  1028.     entry = &tree->entry[0];
  1029.     entries = tree->entries;
  1030.  
  1031.     for (i = 0; ++i < entries; )  {
  1032.         tmp = entry[i];
  1033.         b = tmp.BitLength;
  1034.         j = i;
  1035.         while ((j > 0)
  1036.         && ((a = (ejm1 = &entry[j - 1])->BitLength) >= b))  {
  1037.             if ((a == b) && (ejm1->Value <= tmp.Value))
  1038.                 break;
  1039.             *(ejm1 + 1) = *ejm1;    /* entry[j] = entry[j - 1] */
  1040.             --j;
  1041.         }
  1042.         entry[j] = tmp;
  1043.     }
  1044. } 
  1045.  
  1046.  
  1047. /* ----------------------------------------------------------- */ 
  1048.  
  1049. void         ReadLengths(tree)
  1050. sf_tree *tree;
  1051. { 
  1052.    int          treeBytes;
  1053.    int          i;
  1054.    int          num, len;
  1055.  
  1056.   /* get number of bytes in compressed tree */
  1057.    READBIT(8,treeBytes);
  1058.    treeBytes++; 
  1059.    i = 0; 
  1060.  
  1061.    tree->MaxLength = 0;
  1062.  
  1063.  /* High 4 bits: Number of values at this bit length + 1. (1 - 16)
  1064.     Low  4 bits: Bit Length needed to represent value + 1. (1 - 16) */
  1065.    while (treeBytes > 0)
  1066.    {
  1067.       READBIT(4,len); len++;
  1068.       READBIT(4,num); num++;
  1069.  
  1070.       while (num > 0)
  1071.       {
  1072.          if (len > tree->MaxLength)
  1073.             tree->MaxLength = len;
  1074.          tree->entry[i].BitLength = len;
  1075.          tree->entry[i].Value = i;
  1076.          i++;
  1077.          num--;
  1078.       }
  1079.  
  1080.       treeBytes--;
  1081.    } 
  1082. } 
  1083.  
  1084.  
  1085. /* ----------------------------------------------------------- */ 
  1086.  
  1087. void         GenerateTrees(tree, nodes)
  1088. sf_tree *tree;
  1089. sf_node *nodes;
  1090.      /* Generate the Shannon-Fano trees */ 
  1091. { 
  1092.     int codelen, i, j, lvlstart, next, parents;
  1093.  
  1094.     i = tree->entries - 1;    /* either 255 or 63 */
  1095.     lvlstart = next = 1;
  1096.  
  1097.     /* believe it or not, there may be a 1-bit code */
  1098.  
  1099.     for (codelen = tree->MaxLength; codelen >= 1; --codelen)  {
  1100.  
  1101.         /* create leaf nodes at level <codelen> */
  1102.  
  1103.         while ((i >= 0) && (tree->entry[i].BitLength == codelen))  {
  1104.             nodes[next].left = 0;
  1105.             nodes[next].right = tree->entry[i].Value;
  1106.             ++next;
  1107.             --i;
  1108.         }
  1109.  
  1110.         /* create parent nodes for all nodes at level <codelen>,
  1111.            but don't create the root node here */
  1112.  
  1113.         parents = next;
  1114.         if (codelen > 1)  {
  1115.             for (j = lvlstart; j <= parents-2; j += 2)  {
  1116.                 nodes[next].left = j;
  1117.                 nodes[next].right = j + 1;
  1118.                 ++next;
  1119.             }
  1120.         }
  1121.         lvlstart = parents;
  1122.     }
  1123.  
  1124.     /* create root node */
  1125.  
  1126.     nodes[0].left = next - 2;
  1127.     nodes[0].right = next - 1;
  1128. } 
  1129.  
  1130.  
  1131. /* ----------------------------------------------------------- */ 
  1132.  
  1133. void         LoadTree(tree, treesize, nodes)
  1134. sf_tree *tree;
  1135. int treesize;
  1136. sf_node *nodes;
  1137.      /* allocate and load a shannon-fano tree from the compressed file */ 
  1138. { 
  1139.    tree->entries = treesize; 
  1140.    ReadLengths(tree); 
  1141.    SortLengths(tree); 
  1142.    GenerateTrees(tree, nodes); 
  1143. } 
  1144.  
  1145.  
  1146. /* ----------------------------------------------------------- */ 
  1147.  
  1148. void         LoadTrees()
  1149. { 
  1150.    eightK_dictionary = (lrec.general_purpose_bit_flag & 0x02) != 0;   /* bit 1 */
  1151.    lit_tree_present = (lrec.general_purpose_bit_flag & 0x04) != 0;   /* bit 2 */
  1152.  
  1153.    if (eightK_dictionary) 
  1154.       dict_bits = 7;
  1155.    else 
  1156.       dict_bits = 6; 
  1157.  
  1158.    if (lit_tree_present) 
  1159.    { 
  1160.       minimum_match_length = 3; 
  1161.       LoadTree(&lit_tree,256,lit_nodes);
  1162.    } 
  1163.    else 
  1164.       minimum_match_length = 2; 
  1165.  
  1166.    LoadTree(&length_tree,64,length_nodes);
  1167.    LoadTree(&distance_tree,64,distance_nodes);
  1168. } 
  1169.  
  1170.  
  1171. /* ----------------------------------------------------------- */ 
  1172.  
  1173. #ifndef ASM
  1174.  
  1175. void         ReadTree(nodes, dest)
  1176. register sf_node *nodes;
  1177. int *dest;
  1178.      /* read next byte using a shannon-fano tree */ 
  1179. { 
  1180.     register int cur;
  1181.     register int left;
  1182.     word b;
  1183.  
  1184.     for (cur = 0; ; )  {
  1185.         if ((left = nodes[cur].left) == 0)  {
  1186.             *dest = nodes[cur].right;
  1187.             return;
  1188.         }
  1189.         READBIT(1, b);
  1190.         cur = (b ? nodes[cur].right : left);
  1191.     }
  1192. } 
  1193.  
  1194. #endif
  1195.  
  1196. /* ----------------------------------------------------------- */ 
  1197.  
  1198. void         unImplode()
  1199.      /* expand imploded data */ 
  1200. { 
  1201.    register int srcix;
  1202.    register int Length;
  1203.    register int limit;
  1204.    int          lout;
  1205.    int          Distance;
  1206.  
  1207.    LoadTrees(); 
  1208.  
  1209. #ifdef DEBUG
  1210.    printf("\n");
  1211. #endif
  1212.    while ((!zipeof) && ((outpos+outcnt) < ucsize))
  1213.    { 
  1214.       READBIT(1,lout);
  1215.  
  1216.       if (lout != 0)   /* encoded data is literal data */ 
  1217.       { 
  1218.          if (lit_tree_present)  /* use Literal Shannon-Fano tree */  {
  1219.             ReadTree(lit_nodes,&lout);
  1220. #ifdef DEBUG
  1221.         printf("lit=%d\n", lout);
  1222. #endif
  1223.      }
  1224.          else 
  1225.             READBIT(8,lout);
  1226.  
  1227.          OUTB(lout);
  1228.       } 
  1229.       else             /* encoded data is sliding dictionary match */
  1230.       {                
  1231.          READBIT(dict_bits,Distance);
  1232.  
  1233.          ReadTree(distance_nodes,&lout); 
  1234. #ifdef DEBUG
  1235.      printf("d=%5d (%2d,%3d)", (lout << dict_bits) | Distance, lout,
  1236.             Distance);
  1237. #endif
  1238.          Distance |= (lout << dict_bits);
  1239.          /* using the Distance Shannon-Fano tree, read and decode the
  1240.             upper 6 bits of the Distance value */ 
  1241.  
  1242.          ReadTree(length_nodes,&lout);
  1243.      Length = lout;
  1244. #ifdef DEBUG
  1245.      printf("\tl=%3d\n", Length);
  1246. #endif
  1247.          /* using the Length Shannon-Fano tree, read and decode the
  1248.             Length value */
  1249.  
  1250.          if (Length == 63)
  1251.          { 
  1252.             READBIT(8,lout);
  1253.             Length += lout; 
  1254.          } 
  1255.          Length += minimum_match_length; 
  1256.  
  1257.         /* move backwards Distance+1 bytes in the output stream, and copy
  1258.           Length characters from this position to the output stream.
  1259.           (if this position is before the start of the output stream,
  1260.           then assume that all the data before the start of the output
  1261.           stream is filled with zeros.  Requires initializing outbuf
  1262.       for each file.) */ 
  1263.  
  1264.     srcix = (outcnt - (Distance + 1)) & (OUTBUFSIZ-1);
  1265.     limit = OUTBUFSIZ - Length;
  1266.     if ((srcix <= limit) && (outcnt < limit))  {
  1267.         memcpy(outptr, &outbuf[srcix], Length);
  1268.         outptr += Length;
  1269.         outcnt += Length;
  1270.     }
  1271.     else {
  1272.         while (Length--)  {
  1273.             OUTB(outbuf[srcix++]);
  1274.             srcix &= OUTBUFSIZ-1;
  1275.         }
  1276.     }
  1277.  
  1278.       } 
  1279.    } 
  1280. } 
  1281.  
  1282.  
  1283.  
  1284. /* ---------------------------------------------------------- */
  1285.  
  1286. /*
  1287.  Length  Method   Size  Ratio   Date    Time   CRC-32    Name
  1288.  ------  ------   ----- -----   ----    ----   ------    ----
  1289.   44004  Implode  13041  71%  11-02-89  19:34  88420727  DIFF3.C
  1290.  */
  1291.  
  1292. void dir_member()
  1293. {
  1294.     char *method;
  1295.     int ratio;
  1296.     int yr, mo, dy, hh, mm;
  1297.  
  1298.     yr = (((lrec.last_mod_file_date >> 9) & 0x7f) + 80);
  1299.     mo = ((lrec.last_mod_file_date >> 5) & 0x0f);
  1300.     dy = (lrec.last_mod_file_date & 0x1f);
  1301.  
  1302.     hh = ((lrec.last_mod_file_time >> 11) & 0x1f);
  1303.     mm = ((lrec.last_mod_file_time >> 5) & 0x3f);
  1304.  
  1305.     switch (lrec.compression_method)  {
  1306.     case 0:
  1307.         method = "Stored";
  1308.         break;
  1309.     case 1:
  1310.         method = "Shrunk";
  1311.         break;
  1312.     case 2:
  1313.     case 3:
  1314.     case 4:
  1315.     case 5:
  1316.         method = "Reduced";
  1317.         break;
  1318.     case 6:
  1319.         method = "Implode";
  1320.         break;
  1321.     }
  1322.  
  1323.     if (ucsize != 0)  {
  1324.         ratio = (int) ((1000L * (ucsize    - csize)) / ucsize);
  1325.         if ((ratio % 10) >= 5)
  1326.             ratio += 10;
  1327.     }
  1328.     else
  1329.         ratio = 0;    /* can .zip contain 0-size file? */
  1330.  
  1331.     printf("%7ld  %-7s%7ld %3d%%  %02d-%02d-%02d  %02d:%02d  \
  1332. %08lx  %s\n", ucsize, method, csize,
  1333.         ratio / 10, mo, dy, yr, hh, mm,
  1334.         LONGI(lrec.crc32), filename);
  1335.     tot_ucsize += ucsize;
  1336.     tot_csize += csize;
  1337.     ++members;
  1338. }
  1339.  
  1340. /* ---------------------------------------------------------- */
  1341.  
  1342. void skip_member()
  1343. {
  1344.     register long pos;
  1345.     long endbuf;
  1346.     int offset;
  1347.  
  1348.     endbuf = lseek(zipfd, 0L, SEEK_CUR);    /* 1st byte beyond inbuf */
  1349.     pos = endbuf - incnt;            /* 1st compressed byte */
  1350.     pos += csize;        /* next header signature */
  1351.     if (pos < endbuf)  {
  1352.         incnt -= csize;
  1353.         inptr += csize;
  1354.     }
  1355.     else  {
  1356.         offset = pos % BSIZE;        /* offset within block */
  1357.         pos = (pos / BSIZE) * BSIZE;    /* block start */
  1358.             lseek(zipfd, pos, SEEK_SET);
  1359.         incnt = read(zipfd, inbuf, INBUFSIZ);
  1360.         incnt -= offset;
  1361.         inptr = inbuf + offset;
  1362.     }
  1363. }
  1364.  
  1365. /* ---------------------------------------------------------- */
  1366.  
  1367. void extract_member()
  1368. {
  1369.         word     b;
  1370.  
  1371.     bits_left = 0;
  1372.     bitbuf = 0;
  1373.     outpos = 0L;
  1374.     outcnt = 0;
  1375.     outptr = outbuf;
  1376.     zipeof = 0;
  1377.     crc32val = 0xFFFFFFFFL;
  1378.  
  1379.  
  1380.     memset(outbuf, 0, OUTBUFSIZ);
  1381.     if (tflag)
  1382.         fprintf(stderr, "Testing: %-12s ", filename);
  1383.     else
  1384.         /* create the output file with READ and WRITE permissions */
  1385.         if (create_output_file())
  1386.             exit(1);
  1387.  
  1388.         switch (lrec.compression_method) {
  1389.  
  1390.     case 0:        /* stored */
  1391.         {
  1392.             if (!tflag)
  1393.                 fprintf(stderr, " Extracting: %-12s ", filename);
  1394.             if (cflag) fprintf(stderr, "\n");
  1395.             while (ReadByte(&b))
  1396.                 OUTB(b);
  1397.         }
  1398.         break;
  1399.  
  1400.         case 1: {
  1401.             if (!tflag)
  1402.                 fprintf(stderr, "UnShrinking: %-12s ", filename);
  1403.             if (cflag) fprintf(stderr, "\n");
  1404.             unShrink();
  1405.         }
  1406.         break;
  1407.  
  1408.     case 2:
  1409.     case 3:
  1410.     case 4:
  1411.         case 5: {
  1412.             if (!tflag)
  1413.                 fprintf(stderr, "  Expanding: %-12s ", filename);
  1414.             if (cflag) fprintf(stderr, "\n");
  1415.             unReduce();
  1416.         }
  1417.         break;
  1418.  
  1419.         case 6: {
  1420.             if (!tflag)
  1421.                             fprintf(stderr, "  Exploding: %-12s ", filename);
  1422.             if (cflag) fprintf(stderr, "\n");
  1423.                         unImplode();
  1424.         }
  1425.         break;
  1426.  
  1427.         default:
  1428.         fprintf(stderr, "Unknown compression method.");
  1429.     }
  1430.  
  1431.  
  1432.     /* write the last partial buffer, if any */
  1433.     if (outcnt > 0) {
  1434.         UpdateCRC(outbuf, outcnt);
  1435.         if (!tflag)
  1436.             write(outfd, outbuf, outcnt);
  1437.     }
  1438.  
  1439.     if (!tflag)  {
  1440. #ifndef UNIX
  1441.         /* set output file date and time */
  1442.         set_file_time();
  1443.         close(outfd);
  1444. #else
  1445.         close(outfd);
  1446.         /* set output file date and time */
  1447.         set_file_time();
  1448. #endif
  1449.     }
  1450.  
  1451.     crc32val = ~crc32val;
  1452.         if (crc32val != LONGI(lrec.crc32))
  1453.                 fprintf(stderr, " Bad CRC %08lx  (should be %08lx)", crc32val,
  1454.             LONGI(lrec.crc32));
  1455.     else if (tflag)
  1456.         fprintf(stderr, " OK");
  1457.  
  1458.     fprintf(stderr, "\n");
  1459. }
  1460.  
  1461.  
  1462. /* ---------------------------------------------------------- */
  1463.  
  1464. void get_string(len, s)
  1465. int len;
  1466. char *s;
  1467. {
  1468.     readbuf(zipfd, s, len);
  1469.     s[len] = 0;
  1470. }
  1471.  
  1472.  
  1473. /* ---------------------------------------------------------- */
  1474.  
  1475. void process_local_file_header(fnamev)
  1476. char **fnamev;
  1477. {
  1478.     int extracted;
  1479.  
  1480.     readbuf(zipfd, &lrec, sizeof(lrec));
  1481.  
  1482. #ifdef HIGH_LOW
  1483.     swap_bytes(&lrec.filename_length);
  1484.     swap_bytes(&lrec.extra_field_length);
  1485.     swap_lbytes(LONGIP(lrec.compressed_size));
  1486.     swap_lbytes(LONGIP(lrec.uncompressed_size));
  1487.     swap_bytes(&lrec.compression_method);
  1488.     swap_bytes(&lrec.version_needed_to_extract);
  1489.         swap_bytes(&lrec.general_purpose_bit_flag);
  1490.     swap_bytes(&lrec.last_mod_file_time);
  1491.     swap_bytes(&lrec.last_mod_file_date);
  1492.         swap_lbytes(LONGIP(lrec.crc32));
  1493. #endif
  1494.     csize = LONGI(lrec.compressed_size);
  1495.     ucsize = LONGI(lrec.uncompressed_size);
  1496.  
  1497.     get_string(lrec.filename_length, filename);
  1498.     get_string(lrec.extra_field_length, extra);
  1499.  
  1500.     extracted = 0;
  1501.     for (--fnamev; *++fnamev; )  {
  1502.         if (match(filename, *fnamev))  {
  1503.             if (vflag)
  1504.                 dir_member();
  1505.             else  {
  1506.                 extract_member();
  1507.                 extracted = 1;
  1508.             }
  1509.             break;
  1510.         }
  1511.     }
  1512.     if (!extracted)
  1513.         skip_member();
  1514. }
  1515.  
  1516.  
  1517. /* ---------------------------------------------------------- */
  1518.  
  1519. void process_central_file_header()
  1520. {
  1521.     central_directory_file_header rec;
  1522.     char filename[STRSIZ];
  1523.     char extra[STRSIZ];
  1524.     char comment[STRSIZ];
  1525.  
  1526.     readbuf(zipfd, &rec, sizeof(rec));
  1527.  
  1528. #ifdef HIGH_LOW
  1529.     swap_bytes(&rec.filename_length);
  1530.     swap_bytes(&rec.extra_field_length);
  1531.     swap_bytes(&rec.file_comment_length);
  1532. #endif
  1533.  
  1534.         get_string(rec.filename_length, filename);
  1535.     get_string(rec.extra_field_length, extra);
  1536.     get_string(rec.file_comment_length, comment);
  1537. }
  1538.  
  1539.  
  1540. /* ---------------------------------------------------------- */
  1541.  
  1542. void process_end_central_dir()
  1543. {
  1544.     end_central_dir_record rec;
  1545.     char comment[STRSIZ];
  1546.  
  1547.     readbuf(zipfd, &rec, sizeof(rec));
  1548.  
  1549. #ifdef HIGH_LOW
  1550.     swap_bytes(&rec.zipfile_comment_length);
  1551. #endif
  1552.  
  1553.     /* There seems to be no limit to the zipfile
  1554.        comment length.  Some zipfiles have comments
  1555.        longer than 256 bytes.  Currently no use is
  1556.        made of the comment anyway.
  1557.      */
  1558. #if 0
  1559.     get_string(rec.zipfile_comment_length, comment);
  1560. #endif
  1561. }
  1562.  
  1563.  
  1564. /* ---------------------------------------------------------- */
  1565.  
  1566. void process_headers()
  1567. {
  1568.     int ratio;
  1569.     longint sig;
  1570.  
  1571.     if (vflag)  {
  1572.         members = 0;
  1573.         tot_ucsize = tot_csize = 0;
  1574.         printf("\n Length  Method   Size  Ratio   Date    Time   \
  1575. CRC-32    Name\n ------  ------   ----- -----   ----    ----   ------    \
  1576. ----\n");
  1577.     }
  1578.  
  1579.     while (1) {
  1580.         if (readbuf(zipfd, &sig, sizeof(sig)) != sizeof(sig))
  1581.             return;
  1582.  
  1583. #ifdef HIGH_LOW
  1584.         swap_lbytes(&sig);
  1585. #endif
  1586.  
  1587.                 if (sig == LOCAL_FILE_HEADER_SIGNATURE)
  1588.             process_local_file_header(fnv);
  1589.                 else if (sig == CENTRAL_FILE_HEADER_SIGNATURE)
  1590.             process_central_file_header();
  1591.                 else if (sig == END_CENTRAL_DIR_SIGNATURE) {
  1592.             process_end_central_dir();
  1593.             break;
  1594.         }
  1595.                 else {
  1596.             fprintf(stderr, "Invalid Zipfile Header\n");
  1597.             return;
  1598.         }
  1599.     }
  1600.     if (vflag)  {
  1601.         if (tot_ucsize != 0)  {
  1602.             ratio = (int) ((1000L * (tot_ucsize-tot_csize))
  1603.                     / tot_ucsize);
  1604.             if ((ratio % 10) >= 5)
  1605.                 ratio += 10;
  1606.         }
  1607.         else
  1608.             ratio = 0;
  1609.         printf(" ------          ------  \
  1610. ---                             -------\n\
  1611. %7ld         %7ld %3d%%                             %7d\n",
  1612.         tot_ucsize, tot_csize, ratio / 10, members);
  1613.     }
  1614. }
  1615.  
  1616.  
  1617. /* ---------------------------------------------------------- */
  1618.  
  1619. void process_zipfile()
  1620. {
  1621.     /*
  1622.      * open the zipfile for reading and in BINARY mode to prevent cr/lf
  1623.      * translation, which would corrupt the bitstreams 
  1624.      */
  1625.  
  1626.     if (open_input_file())
  1627.         exit(1);
  1628.  
  1629.     process_headers();
  1630.  
  1631.     close(zipfd);
  1632. }
  1633.  
  1634. /* ---------------------------------------------------------- */
  1635.  
  1636. usage()
  1637. {
  1638.     fprintf(stderr, "\n%s\nCourtesy of:  S.H.Smith  and  The Tool Shop BBS,  (602) 279-2673.\n\n",VERSION);
  1639.     fprintf(stderr, "Usage:  unzip [-tcv] file[.zip] [filespec...]\n\
  1640. \t-t\ttest member files\n\
  1641. \t-c\toutput to stdout\n\
  1642. \t-v\tview directory\n");
  1643.     exit(1);
  1644. }
  1645.  
  1646. /* ---------------------------------------------------------- */
  1647.  
  1648. /*
  1649.  * main program
  1650.  *
  1651.  */
  1652.  
  1653. void main(argc, argv)
  1654. int argc;
  1655. char **argv;
  1656. {
  1657.     char *s;
  1658.     int c;
  1659.  
  1660.     while (--argc > 0 && (*++argv)[0] == '-')  {
  1661.         s = argv[0] + 1;
  1662.         while (c = *s++)  {
  1663.             switch (tolower(c))  {
  1664.             case 't':
  1665.                 ++tflag;
  1666.                 break;
  1667.             case 'v':
  1668.                 ++vflag;
  1669.                 break;
  1670.             case 'c':
  1671.                 ++cflag;
  1672.                 break;
  1673.             default:
  1674.                 usage();
  1675.                 break;
  1676.             }
  1677.         }
  1678.     }
  1679.  
  1680.     if ((tflag && vflag) || (tflag && cflag) || (vflag && cflag))  {
  1681.         fprintf(stderr, "only one of -t, -c, or -v\n");
  1682.         exit(1);
  1683.     }
  1684.     if (argc-- == 0)
  1685.         usage();
  1686.  
  1687.     /* .ZIP default if none provided by user */
  1688.     strcpy(zipfn, *argv++);
  1689.     if (strchr(zipfn, '.') == NULL)
  1690.         strcat(zipfn, ZSUFX);
  1691.  
  1692.     /* if any member file specs on command line, set filename
  1693.        pointer to point to them. */
  1694.  
  1695.     if (argc != 0)
  1696.         fnv = argv;
  1697.  
  1698.         /* allocate i/o buffers */
  1699.     inbuf = (byte *) (malloc(INBUFSIZ));
  1700.     outbuf = (byte *) (malloc(OUTBUFSIZ));
  1701.     if ((inbuf == NULL) || (outbuf == NULL)) {
  1702.         fprintf(stderr, "Can't allocate buffers!\n");
  1703.         exit(1);
  1704.     }
  1705.  
  1706.         /* do the job... */
  1707.         process_zipfile();
  1708.     exit(0);
  1709. }
  1710.