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