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