home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / slfinsta.zip / packinst / unace.c < prev   
C/C++ Source or Header  |  2000-03-26  |  16KB  |  565 lines
  1. /* $Id: unace.c,v 1.1 2000/03/27 04:53:11 ktk Exp $ */
  2.  
  3. /* ------------------------------------------------------------------------ */
  4. /*                                                                          */
  5. /*      Main file of public UNACE.                                          */
  6. /*                                                                          */
  7. /* ------------------------------------------------------------------------ */
  8.  
  9.  
  10. //--------------- include general files ------------------------------------//
  11. #include <ctype.h>      // tolower()
  12. #include <fcntl.h>      // open()
  13. #include <stdio.h>      // printf() sprintf() remove()
  14. #include <stdlib.h>     // malloc()
  15. #include <string.h>     // str*()
  16. #include <sys/types.h>
  17. #include <sys/stat.h>   // S_I*  AMIGA: fstat()
  18.  
  19. #define DIRSEP    '\\'
  20.  
  21. #include <io.h>
  22.  
  23. #if defined(AMIGA)
  24.  #include <error.h>     // errno
  25.  #include <proto/dos.h>
  26. #endif
  27. #if defined(DOS) || defined(WINNT) || defined(WIN16)
  28.   #include <io.h>       // lseek() open() read() write() eof() tell() close()
  29.   #include <dos.h>       // lseek() open() read() write() eof() tell() close()
  30. #endif
  31.  
  32.  
  33. //--------------- include unace specific header files ----------------------//
  34. #include "os.h"
  35.  
  36. #include "globals.h"
  37. #include "portable.h"
  38. #include "uac_comm.h"
  39. #include "uac_crc.h"
  40. #include "uac_crt.h"
  41. #include "uac_dcpr.h"
  42. #include "uac_sys.h"
  43.  
  44. #ifdef CRYPT
  45.  #include "unace_ps.h"
  46. #endif /* CRYPT */
  47. int files=0;
  48.  
  49. //--------------- BEGIN OF UNACE ROUTINES ----------------------------------//
  50.  
  51. int pipeit(char *format, ...) {
  52.    /* Do nothing ... perhaps pipe this somewhere in the future */
  53.    return 0;
  54. } 
  55.  
  56. void init_unace(void)           // initializes unace
  57. {
  58.    buf_rd =malloc(size_rdb * sizeof(ULONG));  // Allocate buffers: increase
  59.    buf    =malloc(size_buf);                  // sizes when possible to speed
  60.    buf_wr =malloc(size_wrb);                  // up the program
  61.    readbuf=malloc(size_headrdb);
  62.  
  63.    if (buf_rd ==NULL ||
  64.        buf    ==NULL ||
  65.        buf_wr ==NULL ||
  66.        readbuf==NULL )
  67.       f_err = ERR_MEM;
  68.  
  69.    make_crctable();             // initialize CRC table
  70.    dcpr_init();                 // initialize decompression
  71.  
  72.    set_handler();               // ctrl+break etc.
  73. }
  74.  
  75. void done_unace(void)
  76. {
  77.    if (buf_rd   ) free(buf_rd   );
  78.    if (buf      ) free(buf      );
  79.    if (buf_wr   ) free(buf_wr   );
  80.    if (readbuf  ) free(readbuf  );
  81.    if (dcpr_text) free(dcpr_text);
  82. }
  83.  
  84. INT  read_header(INT print_err)         // reads any header from archive
  85. {
  86.    USHORT rd,
  87.         head_size,
  88.         crc_ok;
  89.    LONG crc;
  90.    UCHAR *tp=readbuf;
  91.  
  92.    lseek(archan, skipsize, SEEK_CUR);   // skip ADDSIZE block
  93.  
  94.    if (read(archan, &head, 4)<4)
  95.       return (0);                       // read CRC and header size
  96.  
  97. #ifdef HI_LO_BYTE_ORDER
  98.    WORDswap(&head.HEAD_CRC);
  99.    WORDswap(&head.HEAD_SIZE);
  100. #endif
  101.                                         // read size_headrdb bytes into 
  102.    head_size = head.HEAD_SIZE;          // header structure 
  103.    rd = (head_size > size_headrdb) ? size_headrdb : head_size;
  104.    if (read(archan, readbuf, rd) < rd)
  105.       return (0);
  106.    head_size -= rd;
  107.    crc = getcrc(CRC_MASK, readbuf, rd);
  108.  
  109.    while (head_size)                    // skip rest of header
  110.    {                            
  111.       rd = (head_size > size_buf) ? size_buf : head_size;
  112.       if (read(archan, buf, rd) < rd)
  113.          return (0);
  114.       head_size -= rd;
  115.       crc = getcrc(crc, (UCHAR *)buf, rd);
  116.    }
  117.  
  118.    head.HEAD_TYPE =*tp++;               // generic buffer to head conversion
  119.    head.HEAD_FLAGS=BUFP2WORD(tp);
  120.  
  121.    if (head.HEAD_FLAGS & ACE_ADDSIZE)
  122.       skipsize = head.ADDSIZE = BUF2LONG(tp);   // get ADDSIZE
  123.    else
  124.       skipsize = 0;
  125.  
  126.                                                 // check header CRC 
  127.    if (!(crc_ok = head.HEAD_CRC == (crc & 0xffff)) && print_err)
  128.       pipeit("\nError: archive is broken\n");
  129.    else
  130.    switch (head.HEAD_TYPE)              // specific buffer to head conversion
  131.    {
  132.       case MAIN_BLK:
  133.          memcpy(mhead.ACESIGN, tp, acesign_len); tp+=acesign_len;
  134.          mhead.VER_MOD=*tp++;
  135.          mhead.VER_CR =*tp++;
  136.          mhead.HOST_CR=*tp++;
  137.          mhead.VOL_NUM=*tp++;
  138.          mhead.TIME_CR=BUFP2LONG(tp);
  139.          mhead.RES1   =BUFP2WORD(tp);
  140.          mhead.RES2   =BUFP2WORD(tp);
  141.          mhead.RES    =BUFP2LONG(tp);
  142.          mhead.AV_SIZE=*tp++;
  143.          memcpy(mhead.AV, tp, rd-(USHORT)(tp-readbuf));
  144.          break;
  145.       case FILE_BLK:
  146.          fhead.PSIZE     =BUFP2LONG(tp);
  147.          fhead.SIZE      =BUFP2LONG(tp);
  148.          fhead.FTIME     =BUFP2LONG(tp);
  149.          fhead.ATTR      =BUFP2LONG(tp);
  150.          fhead.CRC32     =BUFP2LONG(tp);
  151.          fhead.TECH.TYPE =*tp++;
  152.          fhead.TECH.QUAL =*tp++;
  153.          fhead.TECH.PARM =BUFP2WORD(tp);
  154.          fhead.RESERVED  =BUFP2WORD(tp);
  155.          fhead.FNAME_SIZE=BUFP2WORD(tp);
  156.          memcpy(fhead.FNAME, tp, rd-(USHORT)(tp-readbuf));
  157.          break;
  158. //    default: (REC_BLK and future things): 
  159. //              do nothing 'cause isn't needed for extraction
  160.    }
  161.  
  162.    return (crc_ok);
  163. }
  164.                                 // maximum SFX module size 
  165. #define max_sfx_size 65536      // (needed by read_arc_head)
  166.  
  167. INT read_arc_head(void)         // searches for the archive header and reads it
  168. {
  169.    INT  i,
  170.         flags,
  171.         buf_pos = 0;
  172.    LONG arc_head_pos,
  173.         old_fpos,
  174.         fpos = 0;
  175.    struct stat st;
  176.  
  177.    fstat(archan, &st);
  178.  
  179.    memset(buf, 0, size_buf);
  180.  
  181.    while (tell(archan)<st.st_size && fpos < max_sfx_size)
  182.    {
  183.       old_fpos = fpos;
  184.       fpos += read(archan, &buf[buf_pos], size_buf - buf_pos);
  185.  
  186.       for (i = 0; i < size_buf; i++)    // look for the acesign
  187.       {                         
  188.          if (!memcmp(acesign, &buf[i], acesign_len))
  189.          {             
  190.                                         // seek to the probable begin 
  191.                                         // of the archive
  192.             arc_head_pos = old_fpos + i - buf_pos -  bytes_before_acesign;
  193.             lseek(archan, arc_head_pos, SEEK_SET);
  194.             if (read_header(0))         // try to read archive header
  195.             {                           
  196.                flags = mhead.HEAD_FLAGS;
  197.                adat.sol     = (flags & ACE_SOLID) > 0;
  198.                adat.vol     = (flags & ACE_MULT_VOL) > 0;
  199.                adat.vol_num = mhead.VOL_NUM;
  200.                adat.time_cr = mhead.TIME_CR;
  201.                return (1);
  202.             }
  203.          }
  204.       }
  205.                                         // was no archive header,
  206.                                         // continue search
  207.       lseek(archan, fpos, SEEK_SET);
  208.       memcpy(buf, &buf[size_buf - 512], 512);
  209.       buf_pos = 512;                    // keep 512 old bytes
  210.    }
  211.    return (0);
  212. }
  213.  
  214. INT  open_archive(INT print_err)        // opens archive (or volume)
  215. {
  216.    CHAR av_str[80];
  217.  
  218.    archan = open(aname, O_RDONLY | O_BINARY);   // open file
  219.  
  220.    if (archan == -1)
  221.    {
  222.       pipeit("\nError opening file %s", aname);
  223.       return (0);
  224.    }
  225.    if (!read_arc_head())                        // read archive header
  226.    {                            
  227.       if (print_err)
  228.          pipeit("\nInvalid archive file: %s\n", aname);
  229.       close(archan);
  230.       return (0);
  231.    }
  232.  
  233.    pipeit("\nProcessing archive: %s\n\n", aname);
  234.    if (head.HEAD_FLAGS & ACE_AV)
  235.    {
  236.       pipeit("Authenticity Verification:");   // print the AV
  237.       sprintf(av_str, "\ncreated on %d.%d.%d by ",
  238.               ts_day(adat.time_cr), ts_month(adat.time_cr), ts_year(adat.time_cr));
  239.       pipeit(av_str);
  240.       strncpy(av_str, (char *)mhead.AV, mhead.AV_SIZE);
  241.       av_str[mhead.AV_SIZE] = 0;
  242.       pipeit("%s\n\n", av_str);
  243.    }
  244.    comment_out("Main comment:");        // print main comment
  245.    return (1);
  246. }
  247.  
  248. void get_next_volname(void)             // get file name of next volume
  249. {
  250.    CHAR *cp;
  251.    INT  num;
  252.  
  253.    if ((cp = (CHAR *) strrchr(aname, '.')) == NULL || !*(cp + 1))
  254.       num = -1;
  255.    else
  256.    {
  257.       cp++;
  258.       num = (*(cp + 1) - '0') * 10 + *(cp + 2) - '0';
  259.       if (!in(num, 0, 99))
  260.          num = -1;
  261.       if (in(*cp, '0', '9'))
  262.          num += (*cp - '0') * 100;
  263.    }
  264.    num++;
  265.  
  266.    if (num < 100)
  267.       *cp = 'C';
  268.    else
  269.       *cp = num / 100 + '0';
  270.    *(cp + 1) = (num / 10) % 10 + '0';
  271.    *(cp + 2) = num % 10 + '0';
  272. }
  273.  
  274. INT  proc_vol(void)                     // opens volume
  275. {
  276.    INT  i;
  277.    CHAR s[80];
  278.  
  279.    if (!fileexists(aname) || !f_allvol_pr)
  280.    {
  281.       do
  282.       {
  283.          sprintf(s, "Ready to process %s?", aname);
  284.          beep();
  285.          i = wrask(s);                  // ask whether ready or not
  286.          f_allvol_pr = (i == 1);        // "Always" --> process all volumes
  287.          if (i >= 2)
  288.          {
  289.             f_err = ERR_FOUND;
  290.             return (0);
  291.          }
  292.       }
  293.       while (!fileexists(aname));
  294.    }
  295.  
  296.    if (!open_archive(1))                // open volume
  297.    {                            
  298.       pipeit("\nError while opening archive. File not found or archive broken.\n");
  299.       f_err = ERR_OPEN;
  300.       return (0);
  301.    }
  302.  
  303.    return (1);
  304. }
  305.  
  306. INT  proc_next_vol(void)        // opens next volume to process
  307. {
  308.    close(archan);               // close handle
  309.    get_next_volname();          // get file name of next volume
  310.  
  311.    if (!proc_vol())             // try to open volume, read archive header
  312.       return 0;
  313.    if (!read_header(1))         // read 2nd header
  314.    {
  315.       f_err=ERR_READ;
  316.       return 0;
  317.    }
  318.    return 1;
  319. }
  320.  
  321. INT  read_adds_blk(CHAR * buffer, INT len)      // reads part of ADD_SIZE block
  322. {
  323.    INT  rd = 0,
  324.         l = len;
  325.    LONG i;
  326.  
  327. #ifdef CRYPT
  328.    char *cbuffer=buffer;
  329.  
  330.    if (head.HEAD_TYPE == FILE_BLK && (head.HEAD_FLAGS & ACE_PASSW))
  331.       len = crypt_len(len);
  332. #endif /* CRYPT */
  333.    while (!f_err && len && skipsize)
  334.    {
  335.       i = (skipsize > len) ? len : skipsize;
  336.       skipsize -= i;
  337.  
  338.       errno = 0;
  339.       rd += read(archan, buffer, i);
  340.       if (errno)
  341.       {
  342.          pipeit("\nRead error\n");
  343.          f_err = ERR_READ;
  344.       }
  345.  
  346.       buffer += i;
  347.       len -= i;
  348.  
  349.       if (!skipsize)            // if block is continued on next volume
  350.          if (head.HEAD_FLAGS & ACE_SP_AFTER && !proc_next_vol())
  351.             break;
  352.    }
  353. #ifdef CRYPT
  354.    if (head.HEAD_TYPE == FILE_BLK && (head.HEAD_FLAGS & ACE_PASSW))
  355.       decrypt(cbuffer, rd);
  356. #endif /* CRYPT */
  357.  
  358.    return (rd > l ? l : rd);
  359. }
  360.  
  361. void crc_print(void)            // checks CRC, prints message
  362. {
  363.    INT  crc_not_ok = rd_crc != fhead.CRC32;  /* check CRC of file */
  364.  
  365.    if (!f_err)                  // print message
  366.    {                            
  367.       pipeit(crc_not_ok ? "          CRC-check error" : "          CRC OK");
  368.       flush;
  369.    }
  370. }
  371.  
  372. void analyze_file(void)         // analyzes one file (for solid archives)
  373. {
  374.    pipeit("\n Analyzing");
  375.    flush;
  376.    while (!cancel() && (dcpr_adds_blk(buf_wr, size_wrb))) // decompress only
  377.       ;
  378.    crc_print();
  379. }
  380.  
  381. void extract_file(void)         // extracts one file
  382. {
  383.    INT  rd;
  384.  
  385.    pipeit("\n Extracting");
  386.    flush;                       // decompress block
  387.    while (!cancel() && (rd = dcpr_adds_blk(buf_wr, size_wrb)))
  388.    {
  389.       if (write(wrhan, buf_wr, rd) != rd)       // write block
  390.       {                         
  391.          pipeit("\nWrite error\n");
  392.          f_err = ERR_WRITE;
  393.       }
  394.    }
  395.    crc_print();
  396. }
  397.  
  398. /* extracts or tests all files of the archive
  399.  */
  400. void extract_files(int nopath, int test)
  401. {
  402.    CHAR file[PATH_MAX];
  403.  
  404.    while (!cancel() && read_header(1))
  405.    {
  406.       if (head.HEAD_TYPE == FILE_BLK)
  407.       {
  408.          comment_out("File comment:");   // show file comment
  409.          ace_fname(file, &head, nopath); // get file name
  410.          pipeit("\n%s", file);
  411.          flush;
  412.          dcpr_init_file();               // initialize decompression of file
  413.          if (!f_err)
  414.          {
  415.             if (test || 
  416.                 (wrhan = create_dest_file(file, (INT) fhead.ATTR))<0)
  417.             {
  418.                if (test || adat.sol)
  419.                   analyze_file();        // analyze file
  420.             }
  421.             else
  422.             {
  423.                extract_file();           // extract it
  424. #ifdef DOS                               // set file time
  425.                _dos_setftime(wrhan, (USHORT) (fhead.FTIME >> 16), (USHORT) fhead.FTIME);
  426. #endif
  427.                close(wrhan);
  428. #ifdef DOS                               // set file attributes
  429.                _dos_setfileattr(file, (UINT) fhead.ATTR);
  430. #endif
  431. #ifdef AMIGA
  432.                {                         // set file date and time
  433.                   struct DateTime dt;
  434.                   char Date[9], Time[9];
  435.                   ULONG tstamp=fhead.FTIME;
  436.  
  437.                   sprintf(Date, "%02d-%02d-%02d", ts_year(tstamp)-1900, ts_month(tstamp), ts_day(tstamp));
  438.                   sprintf(Time, "%02d:%02d:%02d", ts_hour(tstamp), ts_min(tstamp), ts_sec(tstamp));
  439.  
  440.                   dt.dat_Format = FORMAT_INT;
  441.                   dt.dat_Flags  = 0;
  442.                   dt.dat_StrDate= Date;
  443.                   dt.dat_StrTime= Time;
  444.  
  445.                   if (StrToDate(&dt))
  446.                      SetFileDate(file, &dt.dat_Stamp);
  447.                }
  448. #endif
  449.                if (f_err)
  450.                   remove(file);
  451.             }
  452.          }
  453.       }
  454.    }
  455. }
  456.  
  457. unsigned percentage(ULONG p, ULONG d)
  458. {
  459.    return (unsigned)( d ? (d/2+p*100)/d : 100 );
  460. }
  461.  
  462. void list_files(int verbose)
  463. {
  464.    ULONG    size =0,
  465.             psize=0,
  466.             tpsize;
  467.    CHAR     file[PATH_MAX];
  468.  
  469.    pipeit("Date    |Time |Packed     |Size     |Ratio|File\n");
  470.  
  471.    while (!cancel() && read_header(1))
  472.    {
  473.       if (head.HEAD_TYPE == FILE_BLK)
  474.       {
  475.          ULONG ti=fhead.FTIME;
  476.          ace_fname(file, &head, verbose ? 0 : 1); // get file name
  477.  
  478.          size  += fhead.SIZE;
  479.          psize +=
  480.          tpsize = fhead.PSIZE;
  481.          files++;
  482.  
  483.          while (head.HEAD_FLAGS & ACE_SP_AFTER)
  484.          {
  485.             skipsize=0;
  486.             if (!proc_next_vol())
  487.                break;
  488.             psize += fhead.PSIZE;
  489.             tpsize+= fhead.PSIZE;
  490.          }
  491.          if (!f_err)
  492.             pipeit("%02u.%02u.%02u|%02u:%02u|%c%c%9lu|%9lu|%4u%%|%c%s\n",
  493.                    ts_day (ti), ts_month(ti), ts_year(ti)%100,
  494.                    ts_hour(ti), ts_min  (ti),
  495.                    fhead.HEAD_FLAGS & ACE_SP_BEF   ? '<' : ' ',
  496.                    fhead.HEAD_FLAGS & ACE_SP_AFTER ? '>' : ' ',
  497.                    tpsize, fhead.SIZE, percentage(tpsize, fhead.SIZE),
  498.                    fhead.HEAD_FLAGS & ACE_PASSW    ? '*'    : ' ',
  499.                    file
  500.                   );
  501.       }
  502.    }
  503.    if (!f_err)
  504.    {
  505.       pipeit("\n                 %9lu|%9lu|%4u%%| %u file%s",
  506.              psize,
  507.              size,
  508.              percentage(psize, size),
  509.              files,
  510.              (char*)(files == 1 ? "" : "s")
  511.             );
  512.    }
  513. }
  514.  
  515. void showhelp(void)
  516. {
  517.    pipeit("\n"
  518.           "Usage: UNACE <command> <archive[.ace]>\n"
  519.           "\n"
  520.           "Where <command> is one of:\n"
  521.           "\n"
  522.           "  e   Extract files\n"
  523.           "  l   List archive\n"
  524.           "  t   Test archive integrity\n"
  525.           "  v   List archive (verbose)\n"
  526.           "  x   Extract files with full path"
  527.          );
  528. }
  529.  
  530. int include_unpack(char *bleah)              // processes the archive
  531. {
  532.       CHAR *s;
  533.  
  534.       strcpy(aname, bleah);
  535.  
  536.       init_unace();                              // initialize unace
  537.  
  538.       if (!(s = (CHAR *) strrchr(aname, DIRSEP)))
  539.          s = aname;
  540.       if (!strrchr(s, '.'))
  541.          strcat(aname, ".ACE");
  542.  
  543.       if (open_archive(1))                       // open archive to process
  544.       {
  545.          if (adat.vol_num)
  546.             pipeit("\nFirst volume of archive required!\n");
  547.          else
  548.             list_files   (0   );
  549.  
  550.          close(archan);
  551.          if (f_err)
  552.          {
  553.             pipeit("\nError occurred\n");
  554.             if (f_criterr)
  555.                pipeit("Critical error on drive %c\n", f_criterr);
  556.          }
  557.       }
  558.       else
  559.          f_err = ERR_CLINE;
  560.  
  561.       done_unace();
  562.    return (f_err);
  563. }
  564.  
  565.