home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 9 Archive / 09-Archive.zip / UNZ_OS2.ZIP / UNZIP2.C next >
C/C++ Source or Header  |  1989-07-21  |  22KB  |  980 lines
  1. /*
  2.  * Copyright 1987, 1989 Samuel H. Smith;  All rights reserved
  3.  *
  4.  * This is a component of the ProDoor System.
  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.  *
  16.  * 24-July-89 Modified for OS/2 support Malcolm Greenhalgh
  17.  *            changes made to 'setftime' function.
  18.  */ 
  19.  
  20. #define version  "UnZip:  Zipfile Extract v1.1ß/² of 24-07-89;  (C) 1989 S.H.Smith"
  21.  
  22. typedef unsigned char byte;
  23. typedef long longint;
  24. typedef unsigned word;
  25. typedef char boolean;
  26. #define STRSIZ  256
  27.  
  28. #include <fcntl.h>
  29. #include <sys/types.h>      //...   MCG 24-07-89 for OS/2 version
  30. #include <sys/stat.h>
  31. #include <io.h>
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34.  
  35. #define INCL_DOSFILEMGR     //...   MCG 24-07-89 for OS/2 version
  36. #define INCL_SUB            //...   MCG 24-07-89 for OS/2 version
  37. #include <os2.h>            //...   MCG 24-07-89 for OS/2 version
  38.  
  39.  
  40. /* ----------------------------------------------------------- */ 
  41. /*
  42.  * Zipfile layout declarations
  43.  *
  44.  */ 
  45.  
  46.    typedef longint       signature_type;
  47.  
  48.  
  49.    #define local_file_header_signature  0x04034b50L
  50.  
  51.  
  52.    typedef struct local_file_header { 
  53.       word         version_needed_to_extract; 
  54.       word         general_purpose_bit_flag; 
  55.       word         compression_method; 
  56.       word         last_mod_file_time; 
  57.       word         last_mod_file_date; 
  58.       longint      crc32; 
  59.       longint      compressed_size; 
  60.       longint      uncompressed_size; 
  61.       word         filename_length; 
  62.       word         extra_field_length; 
  63.    } local_file_header; 
  64.  
  65.  
  66.    #define cntrl_file_header_signature  0x02014b50L
  67.  
  68.  
  69.    typedef struct cntrl_dir_file_header {
  70.       word         version_made_by; 
  71.       word         version_needed_to_extract; 
  72.       word         general_purpose_bit_flag; 
  73.       word         compression_method; 
  74.       word         last_mod_file_time; 
  75.       word         last_mod_file_date; 
  76.       longint      crc32; 
  77.       longint      compressed_size; 
  78.       longint      uncompressed_size; 
  79.       word         filename_length; 
  80.       word         extra_field_length; 
  81.       word         file_comment_length; 
  82.       word         disk_number_start; 
  83.       word         internal_file_attributes; 
  84.       longint      external_file_attributes; 
  85.       longint      relative_offset_local_header; 
  86.    } cntrl_dir_file_header;
  87.  
  88.  
  89.    #define end_cntrl_dir_signature  0x06054b50L
  90.  
  91.  
  92.    typedef struct end_cntrl_dir_record {
  93.       word         number_this_disk; 
  94.       word         number_disk_with_strt_cntrl_dir;
  95.       word         total_entries_cntrl_dir_on_disk;
  96.       word         total_entries_cntrl_dir;
  97.       longint      size_cntrl_dir;
  98.       longint      offset_start_cntrl_dir;
  99.       word         zipfile_comment_length; 
  100.    } end_cntrl_dir_record;
  101.  
  102.  
  103.  
  104. /* ----------------------------------------------------------- */ 
  105. /*
  106.  * input file variables
  107.  *
  108.  */ 
  109.  
  110.  
  111.    #define           uinbufsize    512L   /* input buffer size */
  112.    byte              inbuf[uinbufsize];
  113.  
  114.    boolean           zipeof;
  115.    longint           csize;
  116.    longint           cusize;
  117.    int               cmethod;
  118.    int               inpos;
  119.    int               incnt;
  120.    int               pc;
  121.    int               pcbits;
  122.    int               pcbitv;
  123.    
  124.    int               zipfd;
  125.    char              zipfn[STRSIZ];
  126.    local_file_header lrec;
  127.    FILESTATUS        fistat;
  128.    USHORT            filevel;
  129.  
  130.  
  131.  
  132. /* ----------------------------------------------------------- */ 
  133. /*
  134.  * output stream variables
  135.  *
  136.  */ 
  137.  
  138.  
  139.    byte     outbuf[4096];   /* for rle look-back */
  140.    longint  outpos;         /* absolute position in outfile */
  141.    int      outcnt;
  142.  
  143.    int      outfd;
  144.    char     filename[STRSIZ];
  145.    char     extra[STRSIZ];
  146.  
  147.  
  148.  
  149. /* ----------------------------------------------------------- */ 
  150. /*
  151.  * shrink/reduce working storage
  152.  *
  153.  */ 
  154.  
  155.  
  156.    int      factor;
  157.    byte     followers[256][64];
  158.    byte     Slen[256];
  159.    int      ExState;
  160.    int      C;
  161.    int      V;
  162.    int      Len;
  163.  
  164.    #define max_bits      13
  165.    #define init_bits     9
  166.    #define hsize         8192
  167.    #define first_ent     257
  168.    #define clear         256
  169.  
  170.    typedef int  hsize_array_integer[hsize+1];
  171.    typedef byte hsize_array_byte[hsize+1];
  172.  
  173.    hsize_array_integer prefix_of;
  174.    hsize_array_byte    suffix_of;
  175.    hsize_array_byte    stack;
  176.  
  177.    int      cbits;
  178.    int      maxcode;
  179.    int      free_ent;
  180.    int      maxcodemax;
  181.    int      offset;
  182.    int      sizex;
  183.  
  184.  
  185. /* ------------------------------------------------------------- */ 
  186.  
  187. void         skip_csize(void)
  188. { 
  189.    lseek(zipfd,csize,SEEK_CUR);
  190.    zipeof = 1;
  191.    csize = 0L; 
  192.    incnt = 0; 
  193. } 
  194.  
  195.  
  196. /* ------------------------------------------------------------- */ 
  197.  
  198. void         ReadByte(int *       x)
  199. { 
  200.    if (incnt == 0) 
  201.    { 
  202.       if (csize == 0L) 
  203.       { 
  204.          zipeof = 1;
  205.          return;
  206.       } 
  207.  
  208.       inpos = sizeof(inbuf);
  209.       if (inpos > csize) 
  210.          inpos = (int)csize;
  211.       incnt = read(zipfd,inbuf,inpos);
  212.  
  213.       inpos = 1; 
  214.       csize -= incnt; 
  215.    } 
  216.  
  217.    *x = inbuf[inpos-1]; 
  218.    inpos++; 
  219.    incnt--; 
  220. } 
  221.  
  222.  
  223. /* ------------------------------------------------------------- */ 
  224.  
  225. void         ReadBits(int      bits,
  226.                       int *    x)
  227.      /* read the specified number of bits */ 
  228. { 
  229.    int      bit;
  230.    int      bitv;
  231.  
  232.    *x = 0;
  233.    bitv = 1;
  234.  
  235.    for (bit = 0; bit <= bits-1; bit++)
  236.    { 
  237.  
  238.       if (pcbits > 0) 
  239.       { 
  240.          pcbits--; 
  241.          pcbitv = pcbitv << 1; 
  242.       } 
  243.       else 
  244.  
  245.       { 
  246.          ReadByte(&pc); 
  247.          pcbits = 7; 
  248.          pcbitv = 1; 
  249.       } 
  250.  
  251.       if ((pc & pcbitv) != 0) 
  252.          *x = *x | bitv; 
  253.  
  254.       bitv = (int) (bitv << 1);
  255.    } 
  256.  
  257. } 
  258.  
  259.  
  260. /* ---------------------------------------------------------- */ 
  261.  
  262. void         get_string(int      len,
  263.                         char *   s)
  264. { 
  265.    read(zipfd,s,len);
  266.    s[len] = 0;
  267. } 
  268.  
  269.  
  270. /* ------------------------------------------------------------- */ 
  271.  
  272. void         OutByte(int      c)
  273.    /* output each character from archive to screen */ 
  274. { 
  275.    outbuf[outcnt /* outpos % sizeof(outbuf) */] = c;
  276.    outpos++; 
  277.    outcnt++;
  278.  
  279.    if (outcnt == sizeof(outbuf)) 
  280.    { 
  281.       write(outfd,outbuf,outcnt);
  282.       outcnt = 0; 
  283.       printf("."); 
  284.    } 
  285. } 
  286.  
  287.  
  288. /* ----------------------------------------------------------- */
  289.    
  290. int         reduce_L(int         x)
  291.    { 
  292.       switch (factor) {
  293.          case 1:   return x & 0x7f; 
  294.          case 2:   return x & 0x3f; 
  295.          case 3:   return x & 0x1f; 
  296.          case 4:   return x & 0x0f; 
  297.       } 
  298.     return 0; /* error */
  299.    } 
  300.  
  301.    
  302. int         reduce_F(int         x)
  303.    { 
  304.       switch (factor) {
  305.          case 1:   if (x == 127) return 2;  else return 3;
  306.          case 2:   if (x == 63) return 2;   else return 3;
  307.          case 3:   if (x == 31) return 2;   else return 3;
  308.          case 4:   if (x == 15) return 2;   else return 3;
  309.       } 
  310.     return 0; /* error */
  311.    } 
  312.  
  313.    
  314. int         reduce_D(int         x,
  315.                      int         y)
  316.    { 
  317.       switch (factor) {
  318.          case 1:   return ((x >> 7) & 0x01) * 256 + y + 1; 
  319.          case 2:   return ((x >> 6) & 0x03) * 256 + y + 1; 
  320.          case 3:   return ((x >> 5) & 0x07) * 256 + y + 1; 
  321.          case 4:   return ((x >> 4) & 0x0f) * 256 + y + 1; 
  322.       } 
  323.     return 0; /* error */
  324.    } 
  325.  
  326.  
  327. int         reduce_B(int         x)
  328.         /* number of bits needed to encode the specified number */ 
  329.    { 
  330.       switch (x - 1) {
  331.          
  332.          case 0:   
  333.          case 1:   return 1; 
  334.          
  335.          case 2:   
  336.          case 3:   return 2; 
  337.          
  338.          case 4:
  339.          case 5:   
  340.          case 6:   
  341.          case 7:   return 3; 
  342.          
  343.          case 8:   
  344.          case 9:   
  345.          case 10:   
  346.          case 11:   
  347.          case 12:   
  348.          case 13:   
  349.          case 14:   
  350.          case 15:   return 4; 
  351.         
  352.          case 16:
  353.          case 17:
  354.          case 18:
  355.          case 19:
  356.          case 20:
  357.          case 21:
  358.          case 22:
  359.          case 23:
  360.          case 24:
  361.          case 25:
  362.          case 26:
  363.          case 27:
  364.          case 28:
  365.          case 29:
  366.          case 30:
  367.          case 31:   return 5;
  368.         
  369.          case 32:
  370.          case 33:
  371.          case 34:
  372.          case 35:
  373.          case 36:
  374.          case 37:
  375.          case 38:
  376.          case 39:
  377.          case 40:
  378.          case 41:
  379.          case 42:
  380.          case 43:
  381.          case 44:
  382.          case 45:
  383.          case 46:
  384.          case 47:
  385.          case 48:
  386.          case 49:
  387.          case 50:
  388.          case 51:
  389.          case 52:
  390.          case 53:
  391.          case 54:
  392.          case 55:
  393.          case 56:
  394.          case 57:
  395.          case 58:
  396.          case 59:
  397.          case 60:
  398.          case 61:
  399.          case 62:
  400.          case 63:   return 6;
  401.  
  402.          case 64:
  403.          case 65:
  404.          case 66:
  405.          case 67:
  406.          case 68:
  407.          case 69:
  408.          case 70:
  409.          case 71:
  410.          case 72:
  411.          case 73:
  412.          case 74:
  413.          case 75:
  414.          case 76:
  415.          case 77:
  416.          case 78:
  417.          case 79:
  418.          case 80:
  419.          case 81:
  420.          case 82:
  421.          case 83:
  422.          case 84:
  423.          case 85:
  424.          case 86:
  425.          case 87:
  426.          case 88:
  427.          case 89:
  428.          case 90:
  429.          case 91:
  430.          case 92:
  431.          case 93:
  432.          case 94:
  433.          case 95:
  434.          case 96:
  435.          case 97:
  436.          case 98:
  437.          case 99:
  438.          case 100:
  439.          case 101:
  440.          case 102:
  441.          case 103:
  442.          case 104:
  443.          case 105:
  444.          case 106:
  445.          case 107:
  446.          case 108:
  447.          case 109:
  448.          case 110:
  449.          case 111:
  450.          case 112:
  451.          case 113:
  452.          case 114:
  453.          case 115:
  454.          case 116:
  455.          case 117:
  456.          case 118:
  457.          case 119:
  458.          case 120:
  459.          case 121:
  460.          case 122:
  461.          case 123:
  462.          case 124:
  463.          case 125:
  464.          case 126:
  465.          case 127:   return 7;
  466.       
  467.       default:       return 8;
  468.       } 
  469.    } 
  470.  
  471.  
  472.  
  473. /* ----------------------------------------------------------- */
  474.  
  475. void         Expand(int      c)
  476.    { 
  477.       #define DLE           144
  478.    
  479.       switch (ExState) {
  480.            
  481.            case 0:
  482.                if (c != DLE)
  483.                    OutByte(c);
  484.                else 
  485.                    ExState = 1; 
  486.            break; 
  487.            
  488.            case 1:
  489.                if (c != 0)
  490.                { 
  491.                    V = c; 
  492.                    Len = reduce_L(V);
  493.                    ExState = reduce_F(Len);
  494.                } 
  495.                else 
  496.                { 
  497.                    OutByte(DLE); 
  498.                    ExState = 0; 
  499.                } 
  500.            break; 
  501.            
  502.            case 2:   { 
  503.                   Len = Len + c; 
  504.                   ExState = 3; 
  505.                } 
  506.            break; 
  507.            
  508.            case 3:   { 
  509.                   int i;
  510.                   longint offset = reduce_D(V,c);
  511.                   longint op = outpos - offset;
  512.  
  513.                   for (i = 0; i <= Len + 2; i++) 
  514.                   { 
  515.                      if (op < 0L) 
  516.                         OutByte(0);
  517.                      else 
  518.                         OutByte(outbuf[(int)(op % sizeof(outbuf))]);
  519.                      op++; 
  520.                   } 
  521.  
  522.                   ExState = 0; 
  523.                } 
  524.          break;
  525.       } 
  526.    } 
  527.  
  528.  
  529. /* ----------------------------------------------------------- */
  530.    
  531. void         LoadFollowers(void)
  532.    { 
  533.       int      x;
  534.       int      i;
  535.       int      b;
  536.  
  537.       for (x = 255; x >= 0; x--) 
  538.       { 
  539.          ReadBits(6,&b); 
  540.          Slen[x] = b;
  541.  
  542.          for (i = 0; i < Slen[x]; i++)
  543.          { 
  544.             ReadBits(8,&b); 
  545.             followers[x][i] = b;
  546.          } 
  547.       } 
  548.    } 
  549.  
  550.  
  551.    
  552. /* ----------------------------------------------------------- */ 
  553.  
  554. /*
  555.  * The Reducing algorithm is actually a combination of two
  556.  * distinct algorithms.  The first algorithm compresses repeated
  557.  * byte sequences, and the second algorithm takes the compressed
  558.  * stream from the first algorithm and applies a probabilistic
  559.  * compression method.
  560.  *
  561.  */ 
  562.  
  563. void         unReduce(void)
  564.      /* expand probablisticly reduced data */ 
  565.  
  566.    { 
  567.  
  568.    int    lchar;
  569.    int    lout;
  570.    int    I;
  571.  
  572.    factor = cmethod - 1; 
  573.    if ((factor < 1) || (factor > 4)) 
  574.    { 
  575.       skip_csize(); 
  576.       return;
  577.    } 
  578.  
  579.    ExState = 0; 
  580.    LoadFollowers(); 
  581.    lchar =  0;
  582.  
  583.    while ((!zipeof) && (outpos < cusize))
  584.    { 
  585.  
  586.       if (Slen[lchar] == 0)
  587.          ReadBits(8,&lout);
  588.       else 
  589.  
  590.       { 
  591.          ReadBits(1,&lout); 
  592.          if (lout != 0) 
  593.             ReadBits(8,&lout);
  594.          else 
  595.          { 
  596.             ReadBits(reduce_B(Slen[lchar]),&I);
  597.             lout = followers[lchar][I];
  598.          } 
  599.       } 
  600.  
  601.       Expand(lout); 
  602.       lchar = lout; 
  603.    } 
  604. } 
  605.  
  606.  
  607. /* ------------------------------------------------------------- */
  608. /*
  609.  * Shrinking is a Dynamic Ziv-Lempel-Welch compression algorithm
  610.  * with partial clearing.
  611.  *
  612.  */ 
  613.  
  614. void         partial_clear(void)
  615. { 
  616.    int      pr;
  617.    int      cd;
  618.  
  619.  
  620.    /* mark all nodes as potentially unused */
  621.    for (cd = first_ent; cd < free_ent; cd++)
  622.       prefix_of[cd] |= 0x8000;
  623.  
  624.  
  625.    /* unmark those that are used by other nodes */
  626.    for (cd = first_ent; cd < free_ent; cd++)
  627.    { 
  628.       pr = prefix_of[cd] & 0x7fff;   /* reference to another node? */ 
  629.       if (pr >= first_ent)           /* flag node as referenced */
  630.          prefix_of[pr] &= 0x7fff;
  631.    } 
  632.  
  633.  
  634.    /* clear the ones that are still marked */ 
  635.    for (cd = first_ent; cd < free_ent; cd++)
  636.       if ((prefix_of[cd] & 0x8000) != 0) 
  637.          prefix_of[cd] = -1;
  638.  
  639.  
  640.    /* find first cleared node as next free_ent */ 
  641.    free_ent = first_ent; 
  642.    while ((free_ent < maxcodemax) && (prefix_of[free_ent] != -1)) 
  643.       free_ent++; 
  644. } 
  645.  
  646.  
  647. /* ------------------------------------------------------------- */
  648.  
  649. void         unShrink(void)
  650.  
  651. { 
  652.    int      stackp;
  653.    int      finchar;
  654.    int      code;
  655.    int      oldcode;
  656.    int      incode;
  657.  
  658.  
  659.    /* decompress the file */ 
  660.    maxcodemax = 1 << max_bits; 
  661.    cbits = init_bits; 
  662.    maxcode = (1 << cbits) - 1; 
  663.    free_ent = first_ent; 
  664.    offset = 0; 
  665.    sizex = 0; 
  666.  
  667.    for (code = maxcodemax; code > 255; code--)
  668.       prefix_of[code] = -1;
  669.  
  670.    for (code = 255; code >= 0; code--) 
  671.    { 
  672.       prefix_of[code] = 0;
  673.       suffix_of[code] = code;
  674.    } 
  675.  
  676.    ReadBits(cbits,&oldcode); 
  677.    if (zipeof) return;
  678.    finchar = oldcode; 
  679.  
  680.    OutByte(finchar); 
  681.  
  682.    stackp = 0; 
  683.  
  684.    while ((!zipeof)) 
  685.    { 
  686.       ReadBits(cbits,&code); 
  687.       if (zipeof) return;
  688.  
  689.       while (code == clear)
  690.       { 
  691.          ReadBits(cbits,&code); 
  692.  
  693.          switch (code) {
  694.             
  695.             case 1:   { 
  696.                   cbits++; 
  697.                   if (cbits == max_bits) 
  698.                      maxcode = maxcodemax;
  699.                   else 
  700.                      maxcode = (1 << cbits) - 1; 
  701.                } 
  702.             break;
  703.  
  704.             case 2:
  705.                   partial_clear();
  706.             break;
  707.          } 
  708.  
  709.          ReadBits(cbits,&code); 
  710.          if (zipeof) return;
  711.       } 
  712.  
  713.    
  714.       /* special case for KwKwK string */
  715.       incode = code;
  716.       if (prefix_of[code] == -1)
  717.       { 
  718.          stack[stackp] = finchar;
  719.          stackp++; 
  720.          code = oldcode; 
  721.       } 
  722.  
  723.  
  724.       /* generate output characters in reverse order */
  725.       while (code >= first_ent)
  726.       { 
  727.          stack[stackp] = suffix_of[code];
  728.          stackp++; 
  729.          code = prefix_of[code];
  730.       } 
  731.  
  732.       finchar = suffix_of[code];
  733.       stack[stackp] = finchar;
  734.       stackp++; 
  735.  
  736.  
  737.       /* and put them out in forward order */
  738.       while (stackp > 0)
  739.       { 
  740.          stackp--; 
  741.          OutByte(stack[stackp]);
  742.       } 
  743.  
  744.  
  745.       /* generate new entry */
  746.       code = free_ent;
  747.       if (code < maxcodemax) 
  748.       { 
  749.          prefix_of[code] = oldcode;
  750.          suffix_of[code] = finchar;
  751.          while ((free_ent < maxcodemax) && (prefix_of[free_ent] != -1))
  752.             free_ent++;
  753.       } 
  754.  
  755.  
  756.       /* remember previous code */
  757.       oldcode = incode; 
  758.    } 
  759.  
  760. } 
  761.  
  762. /* ---------------------------------------------------------- */
  763. //...   MCG 24-07-89 for OS/2 version
  764.  
  765. static int setftime(fn, fd, ft)
  766.    char *fn;
  767.    unsigned fd, ft;
  768. {
  769.    USHORT   eact;
  770.    HDIR     ehand;
  771.    unsigned eflag = 0x01, emode = 0x42;
  772.  
  773.    if (DosOpen(fn, &ehand, &eact, 0L, 0, eflag, emode, 0L))
  774.       return (1);
  775.  
  776.    /* set output file date and time ; modified MCG OS/2 */
  777.    filevel = 1;
  778.    DosQFileInfo (ehand,filevel,&fistat,sizeof(fistat));
  779.    fistat.fdateLastWrite.day   = (fd & 0x1F);
  780.    fistat.fdateLastWrite.month = ((fd >> 5) & 0xF);
  781.    fistat.fdateLastWrite.year  = (fd >> 9);
  782.    fistat.ftimeLastWrite.twosecs = (ft & 0x1F);
  783.    fistat.ftimeLastWrite.minutes = ((ft >> 5) & 0x2F);
  784.    fistat.ftimeLastWrite.hours   = (ft >> 11);
  785.    if (DosSetFileInfo (ehand,filevel,&fistat,sizeof(fistat)))
  786.       return(2);
  787.    return(0);
  788. }
  789.  
  790. /* ---------------------------------------------------------- */ 
  791.  
  792. void         extract_member(void)
  793. { 
  794.    int    b;
  795.  
  796.    union {
  797.         // struct ftime ft;
  798.         struct {
  799.             word ztime;
  800.             word zdate;
  801.         } zt;
  802.     } td;
  803.  
  804. for (b=0; b<sizeof(outbuf); b++) outbuf[b]=0;
  805.    pcbits = 0; 
  806.    incnt = 0; 
  807.    outpos = 0L; 
  808.    outcnt = 0; 
  809.    zipeof = 0;
  810.  
  811.    outfd = creat(filename,S_IWRITE|S_IREAD);
  812.    if (outfd < 1)
  813.    { 
  814.       printf("Can't create output: %s\n",filename); 
  815.       exit(0);
  816.    } 
  817.  
  818.    close(outfd);
  819.    outfd = open(filename,O_RDWR|O_BINARY);
  820.  
  821.  
  822.    switch (cmethod) {
  823.       
  824.       case 0:     /* stored */ 
  825.             { 
  826.                printf(" Extract: %s ...",filename); 
  827.                while ((!zipeof)) 
  828.                { 
  829.                   ReadByte(&b); 
  830.                   OutByte(b); 
  831.                } 
  832.             } 
  833.       break; 
  834.       
  835.       case 1:   { 
  836.                printf("UnShrink: %s ...",filename); 
  837.                unShrink(); 
  838.             } 
  839.       break; 
  840.       
  841.       case 2:   
  842.       case 3:   
  843.       case 4:   
  844.       case 5:   { 
  845.                printf("  Expand: %s ...",filename); 
  846.                unReduce(); 
  847.             } 
  848.       break; 
  849.       
  850.       default: printf("Unknown compression method."); 
  851.    } 
  852.  
  853.    if (outcnt > 0) 
  854.       write(outfd,outbuf,outcnt);
  855.    close(outfd);
  856.    setftime(filename,lrec.last_mod_file_date,lrec.last_mod_file_time);
  857.    printf("  done.\n"); 
  858. } 
  859.  
  860.  
  861. /* ---------------------------------------------------------- */ 
  862.  
  863. void         process_local_file_header(void)
  864. { 
  865.    read(zipfd,&lrec,sizeof(lrec));
  866.    get_string(lrec.filename_length,filename);
  867.    get_string(lrec.extra_field_length,extra);
  868.    csize = lrec.compressed_size;
  869.    cusize = lrec.uncompressed_size;
  870.    cmethod = lrec.compression_method;
  871.    extract_member(); 
  872. } 
  873.  
  874.  
  875. /* ---------------------------------------------------------- */ 
  876.  
  877. void         process_cntrl_file_header(void)
  878. { 
  879.    cntrl_dir_file_header rec;
  880.    char filename[STRSIZ];
  881.    char extra[STRSIZ];
  882.    char comment[STRSIZ];
  883.  
  884.    read(zipfd,&rec,sizeof(rec));
  885.    get_string(rec.filename_length,filename); 
  886.    get_string(rec.extra_field_length,extra); 
  887.    get_string(rec.file_comment_length,comment); 
  888. } 
  889.  
  890.  
  891. /* ---------------------------------------------------------- */ 
  892.  
  893. void         process_end_cntrl_dir(void)
  894. { 
  895.    end_cntrl_dir_record rec;
  896.    char comment[STRSIZ];
  897.  
  898.    read(zipfd,&rec,sizeof(rec));
  899.    get_string(rec.zipfile_comment_length,comment); 
  900. } 
  901.  
  902.  
  903. /* ---------------------------------------------------------- */ 
  904.  
  905. void         process_headers(void)
  906. { 
  907.    longint sig;
  908.  
  909.    while (1)
  910.    { 
  911.       if (read(zipfd,&sig,sizeof(sig)) != sizeof(sig))
  912.          return;
  913.       else 
  914.  
  915.       if (sig == local_file_header_signature) 
  916.          process_local_file_header();
  917.       else 
  918.  
  919.       if (sig == cntrl_file_header_signature)
  920.          process_cntrl_file_header();
  921.       else 
  922.  
  923.       if (sig == end_cntrl_dir_signature)
  924.       { 
  925.          process_end_cntrl_dir();
  926.          return;
  927.       } 
  928.  
  929.       else 
  930.       { 
  931.          printf("Invalid Zipfile Header\n"); 
  932.          return;
  933.       } 
  934.    } 
  935.  
  936. } 
  937.  
  938.  
  939. /* ---------------------------------------------------------- */ 
  940.  
  941. void         extract_zipfile(void)
  942. { 
  943.    zipfd = open(zipfn,O_RDONLY|O_BINARY);
  944.    if (zipfd < 1) {
  945.       printf("Can't open input file: %s\n",zipfn);
  946.       return;
  947.    }
  948.  
  949.    process_headers();
  950.  
  951.    close(zipfd);
  952. } 
  953.  
  954.  
  955. /* ---------------------------------------------------------- */
  956. /*
  957.  * main program
  958.  *
  959.  */ 
  960.  
  961. void main(int argc, char **argv)
  962. {
  963.    char *courtesy = "Courtesy of:  S.H.Smith  and  The Tool Shop BBS,  (602) 279-2673.\n\n";
  964.    VioWrtTTy(version, strlen(version), 0);
  965.    VioWrtTTy(courtesy, strlen(courtesy), 0);
  966.  
  967.    if (argc != 2)
  968.    { 
  969.       VioWrtTTy("Usage:  UnZip FILE[.zip]\n", 25, 0);
  970.       DosExit(0,1);
  971.    } 
  972.  
  973.    strcpy(zipfn,argv[1]);
  974.    if (strchr(zipfn,'.') == NULL)
  975.       strcat(zipfn,".ZIP");
  976.  
  977.    extract_zipfile(); 
  978.    DosExit(0,1);
  979. }
  980.