home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / APPS / dm14.lzh / unarc.c < prev   
Text File  |  1996-07-24  |  8KB  |  239 lines
  1. /* unarc.c unarchiver function for DISKMASTER v1.0 */
  2. /* copyright (c) 1995 by Bob Devries               */
  3. /* email: bdevries@gil.ipswichcity.qld.gov.au      */
  4.  
  5. #include <stdio.h>
  6. #include <modes.h>
  7. #include <strings.h>
  8. #include <errno.h>
  9. #include <direct.h>
  10. #include <module.h>
  11. #include "screen.h"
  12. #include "diskmaster.h"
  13.  
  14. int
  15. unarc(pos)
  16. int pos;
  17. {
  18.         int rewrite, success, x;
  19.         extern char **nameptr;
  20.         char *todir, *olddir, *unarccmd, *extension, *malloc();
  21.         char *ext, *tempdir;
  22.         mod_exec *modloadp(), *modp;
  23.     
  24.         ext = malloc(28);
  25.         todir = malloc(80);
  26.         olddir = malloc(256);
  27.         unarccmd = malloc(256);
  28.         extension = rindex(nameptr[pos],'.');
  29.         strcpy(ext,extension);
  30.         for(x=0;x<=strlen(ext);x++) {
  31.                *(ext+x) = tolower(*(ext+x));
  32.         }
  33.         gotoxy(1,24);
  34.         cleol();
  35.         printf("     %cUnarchive %s to directory: ",7,nameptr[pos]);
  36.         success = lineinput(todir,80);
  37.         if(success == FAIL) {
  38.                free(todir);
  39.                free(olddir);
  40.                free(ext);
  41.                free(unarccmd);
  42.                commands();
  43.                return(FAIL);
  44.         }
  45.         
  46.         getcwd(olddir,256);
  47.         
  48.         if(*todir == '\0') {
  49.                rewrite = PASS;
  50.                printf("current directory.");
  51.         } else {
  52.                if(access(todir,S_IFDIR+S_IREAD+S_IWRITE) != 0) {
  53.                       open_err(todir,errno);
  54.                       free(todir);
  55.                       free(olddir);
  56.                       free(ext);
  57.                       free(unarccmd);
  58.                       commands();
  59.                       return(PASS);
  60.                }
  61.                chdir(todir);
  62.                tempdir = malloc(256);
  63.                getcwd(tempdir,256);
  64.                if(strcmp(tempdir,olddir) == 0) {
  65.                          rewrite = PASS;
  66.                } else {
  67.                          rewrite = FAIL;
  68.                }
  69.                chdir(olddir);
  70.                free(tempdir);
  71.         }
  72.  
  73.         
  74.         if((strcmp(ext,".lzh") == 0) || (strcmp(ext,".lha") == 0)) {
  75.                if ((modp = modloadp("lha",0,NULL)) == NULL) {
  76.                           error("Can't load command","LHA",errno);
  77.                           return(FAIL);
  78.                }
  79.                strcpy(unarccmd,"lha -xw=");
  80.                if(rewrite == PASS) {
  81.                        strcat(unarccmd,". ");
  82.                } else {
  83.                        strcat(unarccmd,todir);
  84.                           strcat(unarccmd," ");
  85.                }
  86.                strcat(unarccmd,nameptr[pos]);
  87.                strcat(unarccmd," >>>/nil");
  88.                gotoxy(1,24);
  89.                cleol();
  90.                printf("     Unarchiving %s to %s.",nameptr[pos],todir);
  91.                system(unarccmd);
  92.                free(todir);
  93.                free(olddir);
  94.                free(ext);
  95.                free(unarccmd);
  96.                commands();
  97.                munlink(modp);
  98.                return(rewrite);
  99.         } else if (strcmp(ext,".zoo") == 0) {
  100.                if ((modp = modloadp("zoo",0,NULL)) == NULL) {
  101.                          error("Can't load command","ZOO",errno);
  102.                          return(FAIL);
  103.                      }
  104.                   strcpy(unarccmd,"zoo -xq ");
  105.                   if(rewrite != PASS) {
  106.                          chdir(todir);
  107.                          strcat(unarccmd,olddir);
  108.                          strcat(unarccmd,"/");
  109.                   }
  110.                   strcat(unarccmd,nameptr[pos]);
  111.                   strcat(unarccmd," >>>/nil");
  112.                   gotoxy(1,24);
  113.                   cleol();
  114.                   printf("     Unarchiving %s to %s.",nameptr[pos],todir);
  115.                   system(unarccmd);
  116.                   chdir(olddir);
  117.                   free(todir);
  118.                   free(olddir);
  119.                   free(ext);
  120.                   free(unarccmd);
  121.                   commands();
  122.                   munlink(modp);
  123.                   return(rewrite);
  124.         } else if (strcmp(ext,".zip") == 0) {
  125.                if ((modp = modloadp("unzip",0,NULL)) == NULL) {
  126.                        error("Can't load command","UNZIP",errno);
  127.                        return(FAIL);
  128.                }
  129.                strcpy(unarccmd,"unzip -xqq ");
  130.                if(rewrite != PASS) {
  131.                       chdir(todir);
  132.                       strcat(unarccmd,olddir);
  133.                       strcat(unarccmd,"/");
  134.                }
  135.                strcat(unarccmd,nameptr[pos]);
  136.                strcat(unarccmd," >>>/nil");
  137.                gotoxy(1,24);
  138.                cleol();
  139.                printf("     Unarchiving %s to %s.",nameptr[pos],todir);
  140.                system(unarccmd);
  141.                chdir(olddir);
  142.                free(todir);
  143.                free(olddir);
  144.                free(ext);
  145.                free(unarccmd);
  146.                commands();
  147.                munlink(modp);
  148.                return(rewrite);
  149.         } else if(strcmp(ext,".gz") == 0) {
  150.                if ((modp = modloadp("gzip",0,NULL)) == NULL) {
  151.                       error("Can't load command","GZIP",errno);
  152.                       return(FAIL);
  153.                }
  154.                strcpy(unarccmd,"gzip -dq ");
  155.                if(rewrite != PASS) {
  156.                       chdir(todir);
  157.                       strcat(unarccmd,olddir);
  158.                       strcat(unarccmd,"/");
  159.                }
  160.                strcat(unarccmd,nameptr[pos]);
  161.                strcat(unarccmd," >>>/nil");
  162.                gotoxy(1,24);
  163.                cleol();
  164.                printf("     Unarchiving %s to %d.",nameptr[pos],todir);
  165.                system(unarccmd);
  166.                chdir(olddir);
  167.                free(todir);
  168.                free(olddir);
  169.                free(ext);
  170.                free(unarccmd);
  171.                commands();
  172.                munlink(modp);
  173.                return(rewrite);
  174.         } else if(strcmp(ext,".ar") == 0) {
  175.                if ((modp = modloadp("ar2",0,NULL)) == NULL) {
  176.                       error("Can't load command","AR2",errno);
  177.                       return(FAIL);
  178.                }
  179.                strcpy(unarccmd,"ar2 -x ");
  180.                if(rewrite != PASS) {
  181.                       chdir(todir);
  182.                       strcat(unarccmd,olddir);
  183.                       strcat(unarccmd,"/");
  184.                }
  185.                strcat(unarccmd,nameptr[pos]);
  186.                strcat(unarccmd," >>>/nil");
  187.                gotoxy(1,24);
  188.                cleol();
  189.                printf("     Unarchiving %s to %s.",nameptr[pos],todir);
  190.                system(unarccmd);
  191.                chdir(olddir);
  192.                free(todir);
  193.                free(olddir);
  194.                free(ext);
  195.                free(unarccmd);
  196.                commands();
  197.                munlink(modp);
  198.                return(rewrite);
  199.         } else if(strcmp(ext,".uue") == 0) {
  200.                if ((modp = modloadp("uudecode",0,NULL)) == NULL) {
  201.                       error("Can't load command","UUDECODE",errno);
  202.                       return(FAIL);
  203.                }
  204.                strcpy(unarccmd,"uudecode ");
  205.                if(rewrite != PASS) {
  206.                       chdir(todir);
  207.                       strcat(unarccmd,olddir);
  208.                       strcat(unarccmd,"/");
  209.                }
  210.                strcat(unarccmd,nameptr[pos]);
  211.                strcat(unarccmd," >>>/nil");
  212.                gotoxy(1,24);
  213.                cleol();
  214.                printf("     Unarchiving %s to %s.",nameptr[pos],todir);
  215.                system(unarccmd);
  216.                chdir(olddir);
  217.                free(todir);
  218.                free(olddir);
  219.                free(ext);
  220.                free(unarccmd);
  221.                commands();
  222.                munlink(modp);
  223.                return(rewrite);
  224.         } else {
  225.                free(todir);
  226.                free(olddir);
  227.                free(ext);
  228.                free(unarccmd);
  229.                gotoxy(1,24);
  230.                cleol();
  231.                printf("     %c%s: Unknown archive type",7,nameptr[pos]);
  232.                sleep(2);
  233.                commands();
  234.                return(FAIL);
  235.         }
  236. }
  237.  
  238. /* EOF unarc.c */
  239.