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