home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 182.lha / CShell_v3.0a / comm2.c < prev    next >
C/C++ Source or Header  |  1988-04-28  |  13KB  |  593 lines
  1. /*
  2.  * COMM2.C
  3.  *
  4.  * (c)1986 Matthew Dillon     9 October 1986
  5.  *
  6.  * Version 2.07M by Steve Drew 10-Sep-87
  7.  *
  8.  * Version 3.00A by Carlo Borreo & Cesare Dieni 30-Oct-88
  9.  *
  10.  */
  11.  
  12. extern char *v_gotofwd;
  13.  
  14. /* Casting conveniences */
  15. #define BPTR_TO_C(strtag, var)  ((struct strtag *)(BADDR( (ULONG) var)))
  16. #define PROC(task)              ((struct Process *)task)
  17. #define CLI(proc)               (BPTR_TO_C(CommandLineInterface, proc->pr_CLI))
  18.  
  19. /* Externs */
  20. extern int has_wild;                    /* flag set if any arg has a ? or * */
  21.  
  22. /* globals */
  23. int cp_update;
  24. int cp_date;
  25.  
  26. do_abortline()
  27. {
  28. Exec_abortline = 1;
  29. return 0;
  30. }
  31.  
  32. do_return()
  33. {
  34. register int retcode=(ac<2 ? 0 : atoi(av[1]));
  35.    Exec_abortline = 1;
  36.    if (Src_stack) {
  37.        FILE *ptr = (FILE *)Src_base[Src_stack - 1];
  38.        ptr->_bp = ptr->_bend;
  39.        ptr->_flags |= _EOF;
  40. /*     fseek (Src_base[Src_stack - 1], 0L, 2); */
  41.       return retcode;
  42.    } else main_exit(retcode);
  43. }
  44.  
  45. /*
  46.  * STRHEAD
  47.  *
  48.  * place a string into a variable removing everything after and including
  49.  * the 'break' character
  50.  *
  51.  * strhead varname breakchar string
  52.  *
  53.  */
  54.  
  55. do_strhead()
  56. {
  57. char *s;
  58. if (s=index(av[3],*av[2])) *s='\0';
  59. set_var (LEVEL_SET, av[1], av[3]);
  60. }
  61.  
  62. do_strtail()
  63. {
  64. char *s;
  65. if (s=index(av[3],*av[2])) s++; else s=av[3];
  66. set_var (LEVEL_SET, av[1], s);
  67. }
  68.  
  69. long dptrtosecs(d)
  70. struct DPTR *d;
  71. {
  72. register struct DateStamp *ds=(&d->fib->fib_Date);
  73. return ds->ds_Days*86400 + ds->ds_Minute*60 + ds->ds_Tick/TICKS_PER_SECOND;
  74. }
  75.  
  76. long timeof(s)
  77. char *s;
  78. {
  79. struct DPTR *d;
  80. int dummy;
  81. long n;
  82.  
  83. if ( (d=dopen(s,&dummy))==NULL ) return 0L;
  84. n=dptrtosecs(d);
  85. dclose(d);
  86. return n;
  87. }
  88.  
  89. /*
  90.  * if -f file (exists) or:
  91.  *
  92.  * if A < B   <, >, =, <=, >=, <>, where A and B are either:
  93.  * nothing
  94.  * a string
  95.  * a value (begins w/ number)
  96.  */
  97.  
  98. do_if(garbage, com)
  99. char *garbage;
  100. {
  101. int result;
  102. int i;
  103.  
  104. switch (com) {
  105.     case 0:
  106.     if (If_stack && If_base[If_stack - 1]) If_base[If_stack++] = 1;
  107.     else {
  108.         get_opt("rftmdn",&i);
  109.         result=evalif(i);
  110.         If_base[If_stack++]=(options & 32 ? result : !result);
  111.         }
  112.     break;
  113.     case 1:
  114.     if (If_stack > 1 && If_base[If_stack - 2]) break;
  115.     if (If_stack) If_base[If_stack - 1] ^= 1;
  116.     break;
  117.     case 2:
  118.     if (If_stack) --If_stack;
  119.     break;
  120.      }
  121. disable = (If_stack) ? If_base[If_stack - 1] : 0;
  122. if (If_stack >= MAXIF) {
  123.     fprintf(stderr,"If's too deep\n");
  124.     disable = If_stack = 0;
  125.     return -1;
  126.     }
  127. if (forward_goto) disable = If_base[If_stack - 1] = 0;
  128. return 0;
  129. }
  130.  
  131. evalif(i)
  132. register unsigned int i;
  133. {
  134. char c;
  135. long num, t0;
  136. long AvailMem();
  137.  
  138. switch(options & ~32) {
  139.     case 0:
  140.     if (ac-i != 3) return (ac>i && *av[i]);
  141.     Errno=0;
  142.     num=Atol(av[i])-Atol(av[i+2]);
  143.     if (Errno) num=strcmp(av[i],av[i+2]);
  144.     if (num < 0)      c='<';
  145.     else if (num > 0) c='>';
  146.     else if (num ==0) c='=';
  147.     return index(av[i+1], c) != NULL;
  148.     case 1:
  149.     return do_rpn(NULL,i);
  150.     case 2:
  151.     return exists(av[i]);
  152.     case 4:
  153.     t0=timeof(av[i++]);
  154.     for ( ; i<ac ; i++)
  155.         if (t0<=timeof(av[i])) return 1;
  156.     return 0;
  157.     case 8:
  158.     return (AvailMem( (long)MEMF_FAST )!=0);
  159.     case 16:
  160.     return (isdir(av[i])!=0);
  161.     default:
  162.     ierror(NULL,500);
  163.     return 0;
  164.     }
  165. }
  166.  
  167. do_label()
  168. {
  169.    char aseek[32];
  170.  
  171.    if (Src_stack == 0) {
  172.       ierror (NULL, 502);
  173.       return (-1);
  174.    }
  175.  
  176.    sprintf (aseek, "%ld %d", Src_pos[Src_stack-1], If_stack);
  177.    set_var (LEVEL_LABEL + Src_stack - 1, av[1], aseek);
  178.    if (!strcmp(av[1],get_var(LEVEL_SET,v_gotofwd)))
  179.       forward_goto = 0;
  180.    return (0);
  181. }
  182.  
  183. do_goto()
  184. {
  185.    int new;
  186.    long pos;
  187.    char *lab;
  188.  
  189.    if (Src_stack == 0) {
  190.       ierror (NULL, 502);
  191.    } else {
  192.       lab = get_var (LEVEL_LABEL + Src_stack - 1, av[1]);
  193.       if (lab == NULL) {
  194.          forward_goto = 1;
  195.          set_var (LEVEL_SET, v_gotofwd, av[1]);
  196.          return(0);
  197.       } else {
  198.          pos = atoi(lab);
  199.          fseek (Src_base[Src_stack - 1], pos, 0);
  200.          Src_pos[Src_stack - 1] = pos;
  201.          new = atoi(next_word(lab));
  202.          for (; If_stack < new; ++If_stack)
  203.             If_base[If_stack] = 0;
  204.          If_stack = new;
  205.       }
  206.    }
  207.    Exec_abortline = 1;
  208.    return (0);      /* Don't execute rest of this line */
  209. }
  210.  
  211.  
  212. do_inc(garbage, com)
  213. char *garbage;
  214. {
  215. char *var, num[32];
  216.  
  217. if (ac>2) com *= atoi(av[2]);
  218. if (var = get_var (LEVEL_SET, av[1])) {
  219.     sprintf (num, "%d", atoi(var)+com);
  220.     set_var (LEVEL_SET, av[1], num);
  221.     }
  222. }
  223.  
  224. do_input()
  225. {
  226. char in[256], *p,*s;
  227. unsigned int i;
  228.  
  229. for (i=1; i < ac; ++i)
  230.     if (gets(in)) {
  231.     for(p = in; *p; p = s) {
  232.         s = next_word(p);
  233.         if (*s) *(s-1) = 0xA0;
  234.         }
  235.     set_var (LEVEL_SET, av[i], in);
  236.     }
  237. return 0;
  238. }
  239.  
  240. do_ver()
  241. {
  242. puts ("Shell V3.00A\n\
  243. (c)1986 Matthew Dillon\n\
  244. Manx (M) versions by Steve Drew\n\
  245. ARP (A) versions by Carlo Borreo & Cesare Dieni\n");
  246. return 0;
  247. }
  248.  
  249. do_ps()
  250. {
  251. /* this code fragment based on ps.c command by Dewi Williams */
  252.  
  253. register int    count;        /* loop variable        */
  254. struct Task    *task;        /* EXEC descriptor        */
  255. char        strbuf[64+1];    /* scratch for btocstr()    */
  256. char        cmd[40+1];    /* holds cmd name        */
  257. long ncli;
  258.  
  259. printf("Proc Command Name         CLI Type    Pri.  Address  Directory\n");
  260. Forbid();
  261.  
  262. ncli=(long)FindCLI(0L);
  263. for (count = 1; count <= ncli ; count++)
  264.         /* or just assume 20?*/
  265.     if (task = (struct Task *)FindCLI((long)count)) {
  266.     if (task==NULL) continue;
  267.     /* Sanity check just in case */
  268.     if (PROC(task)->pr_TaskNum == 0 || PROC(task)->pr_CLI == 0) continue;
  269.                             /* or complain? */
  270.     BtoCStr(cmd,   CLI(PROC(task))->cli_CommandName, 40L);
  271.     BtoCStr(strbuf,CLI(PROC(task))->cli_SetName    , 64L);
  272.     printf("%2d   %-20.20s %-11.11s %3d  %8lx  %s\n",
  273.         count,
  274.         cmd,
  275.         task->tc_Node.ln_Name,
  276.         task->tc_Node.ln_Pri,
  277.         task,
  278.         strbuf);
  279.     }
  280. Permit();
  281. return 0;
  282. }
  283.  
  284. /*
  285.  * CP [-d] [-u] file file
  286.  * CP [-d] [-u] file file file... destdir
  287.  * CP [-r][-u][-d] dir dir dir... destdir
  288.  */
  289.  
  290. char *errstr;          /* let's be alittle more informative */
  291.  
  292. do_copy()
  293. {
  294. register int recur, ierr;
  295. register char *destname;
  296. register char destisdir;
  297. register FIB *fib;
  298. int i;
  299.  
  300. errstr = "";
  301. ierr = 0;
  302.  
  303. fib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  304.  
  305. get_opt("rud",&i);
  306. recur     = (options & 0x01);
  307. cp_update = (options & 0x02);
  308. cp_date   = (!(options & 0x04)); /* the default is keep orignal file date */
  309.  
  310. destname = av[ac - 1];
  311.  
  312. if (ac < i + 2) {
  313.     ierr = 500;
  314.     goto done;
  315.     }
  316. destisdir = isdir(destname);
  317. if (ac > i + 2 && !destisdir) {
  318.     ierr = 507;
  319.     goto done;
  320.     }
  321.  
  322. /*
  323.  * copy set:                        reduce to:
  324.  *    file to file                     file to file
  325.  *    dir  to file (NOT ALLOWED)
  326.  *    file to dir                      dir to dir
  327.  *    dir  to dir                      dir to dir
  328.  *
  329.  */
  330.  
  331. for (; i<ac-1 && !dobreak(); ++i) {
  332.     short srcisdir = isdir(av[i]);
  333.     if (srcisdir && has_wild && (ac >2)) /* hack to stop dir's from */
  334.         continue;             /* getting copied if specified */
  335.                          /* from wild expansion */
  336.     if (srcisdir) {
  337.         BPTR srcdir, destdir;
  338.         if (!destisdir) {
  339.             if (exists(destname)) {
  340.                 ierr = 507;    /* disallow dir to file */
  341.                 goto done;
  342.                 }
  343.             if (destdir = CreateDir(destname)) UnLock(destdir);
  344.             destisdir = 1;
  345.             }
  346.         if (!(destdir = Lock(destname, ACCESS_READ))) {
  347.             ierr = 205;
  348.             errstr = destname;
  349.             goto done;
  350.             }
  351.         if (!(srcdir = Lock(av[i], ACCESS_READ))) {
  352.             ierr = 205;
  353.             errstr = av[i];
  354.             UnLock(destdir);
  355.             goto done;
  356.             }
  357.         ierr = copydir(srcdir, destdir, recur);
  358.         UnLock(srcdir);
  359.         UnLock(destdir);
  360.         if (ierr) break;
  361.         }
  362.     else {        /* FILE to DIR,   FILE to FILE   */
  363.         BPTR destdir, srcdir, tmp;
  364.         char *destfilename;
  365.  
  366.         srcdir = (BPTR)(Myprocess->pr_CurrentDir);
  367.  
  368.         if ((tmp = Lock(av[i], ACCESS_READ)) == NULL || !Examine(tmp,fib)) {
  369.             if (tmp) UnLock(tmp);
  370.             ierr = 205;
  371.             errstr = av[i];
  372.             goto done;
  373.             }
  374.         UnLock(tmp);
  375.         if (destisdir) {
  376.             destdir = Lock(destname, ACCESS_READ);
  377.             destfilename = fib->fib_FileName;
  378.             }
  379.         else {
  380.             destdir = srcdir;
  381.             destfilename = destname;
  382.             }
  383.         printf(" %s..",av[i]);
  384.         fflush(stdout);
  385.         ierr = copyfile(av[i], srcdir, destfilename, destdir);
  386.         if (destisdir) UnLock(destdir);
  387.         if (ierr) break;
  388.         }
  389.     }
  390.  
  391. done:
  392.  
  393. FreeMem(fib, (long)sizeof(FIB));
  394. if (ierr) {
  395.     ierror(errstr, ierr);
  396.     return(20);
  397.     }
  398. return 0;
  399. }
  400.  
  401.  
  402. copydir(srcdir, destdir, recur)
  403. register BPTR srcdir, destdir;
  404. {
  405.    BPTR cwd;
  406.    register FIB *srcfib;
  407.    register BPTR destlock, srclock;
  408.    int ierr;
  409.    static int level;
  410.  
  411.    level++;
  412.    ierr = 0;
  413.    srcfib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  414.    if (Examine(srcdir, srcfib)) {
  415.       while (ExNext(srcdir, srcfib)) {
  416.          if (CHECKBREAK())
  417.             break;
  418.          if (srcfib->fib_DirEntryType < 0) {
  419.             printf("%*s%s..",(level-1) * 6," ",srcfib->fib_FileName);
  420.             fflush(stdout);
  421.             ierr = copyfile(srcfib->fib_FileName,srcdir,srcfib->fib_FileName,destdir);
  422.             if (ierr)
  423.                break;
  424.          } else {
  425.             if (recur) {
  426.                cwd = CurrentDir(srcdir);
  427.                if (srclock = Lock(srcfib->fib_FileName, ACCESS_READ)) {
  428.                   CurrentDir(destdir);
  429.                   if (!(destlock = Lock(srcfib->fib_FileName))) {
  430.                      destlock = CreateDir(srcfib->fib_FileName);
  431.                      printf("%*s%s (Dir)....[Created]\n",(level-1) * 6,
  432.                                 " ",srcfib->fib_FileName);
  433.  
  434.                         /* UnLock and re Lock if newly created
  435.                            for file_date() to work properly
  436.                         */
  437.                      if (destlock) UnLock(destlock);
  438.                      destlock = Lock(srcfib->fib_FileName);
  439.                   }
  440.                   else
  441.                      printf("%*s%s (Dir)\n",(level-1) * 6," ",srcfib->fib_FileName);
  442.                   if (destlock) {
  443.                      ierr = copydir(srclock, destlock, recur);
  444.                      UnLock(destlock);
  445.                   } else {
  446.                      ierr = (int)((long)IoErr());
  447.                   }
  448.                   UnLock(srclock);
  449.                } else {
  450.                   ierr = (int)((long)IoErr());
  451.                }
  452.                CurrentDir(cwd);
  453.                if (ierr)
  454.                   break;
  455.             }
  456.          }
  457.       }
  458.    } else {
  459.       ierr = (int)((long)IoErr());
  460.    }
  461.    --level;
  462.    FreeMem(srcfib, (long)sizeof(FIB));
  463.    return(ierr);
  464. }
  465.  
  466.  
  467. copyfile(srcname, srcdir, destname, destdir)
  468. char *srcname, *destname;
  469. BPTR srcdir, destdir;
  470. {
  471. BPTR cwd;
  472. BPTR f1, f2;
  473. long i;
  474. int stat,ierr;
  475. char *buf;
  476. struct DPTR *dp, *dps = NULL;
  477.  
  478. if ((buf = (char *)AllocMem(8192L, MEMF_PUBLIC|MEMF_CLEAR))==NULL)
  479.     { ierr = 103; goto fail; }
  480. ierr = 0;
  481. cwd = CurrentDir(srcdir);
  482. if ((f1=Open(srcname, MODE_OLDFILE))==NULL)
  483.     { errstr = srcname; ierr = 205; goto fail; }
  484. dps = dopen(srcname,&stat);
  485. CurrentDir(destdir);
  486. if (cp_update)
  487.     {
  488.     dp=dopen(destname, &stat);
  489.     if ( dptrtosecs(dp) >= dptrtosecs(dps) &&
  490.         !strcmp(dps->fib->fib_FileName, dp->fib->fib_FileName))
  491.         { dclose(dp); Close(f1); printf("..not newer\n"); goto fail; }
  492.     dclose(dp);
  493.     }
  494. if ((f2=Open(destname, MODE_NEWFILE))==NULL)
  495.     { Close(f1); ierr = (int)((long)IoErr()); errstr=destname; goto fail;  }
  496. while (i = Read(f1, buf, 8192L))
  497.     if (Write(f2, buf, i) != i) { ierr = (int)((long)IoErr()); break; }
  498. Close(f2);
  499. Close(f1);
  500. if (!ierr)
  501.     {
  502.     if (cp_date) file_date(&dps->fib->fib_Date, destname);
  503.     printf("..copied\n");
  504.     }
  505. else DeleteFile(destname);
  506. fail:
  507.  dclose(dps);
  508.  if (buf) FreeMem(buf, 8192L);
  509.  CurrentDir(cwd);
  510.  return(ierr);
  511. }
  512.  
  513. do_touch()
  514. {
  515. struct DateStamp ds;
  516. register unsigned int i;
  517. DateStamp(&ds);
  518. for (i=1; i<ac; i++) if (file_date(&ds, av[i])) ierror(av[i],500);
  519. }
  520.  
  521. file_date(date,name)
  522. struct DateStamp *date;
  523. char *name;
  524. {
  525. long packargs[7];
  526. UBYTE *ptr;
  527. struct MsgPort *task;
  528. BPTR dirlock;
  529. struct DPTR *tmp;
  530. int stat;
  531.  
  532. if (!(task = (struct MsgPort *)DeviceProc(name))) return(1);
  533. if (tmp = dopen(name, &stat)) {
  534.     dirlock = ParentDir(tmp->lock);
  535.     ptr=AllocMem(65L,MEMF_PUBLIC);
  536.     CtoBStr(tmp->fib->fib_FileName,(ULONG)ptr >> 2L,64L);
  537.     dclose(tmp);
  538.     packargs[1]=dirlock;
  539.     packargs[2]=(ULONG)ptr >> 2L;
  540.     packargs[3]=(long)date;
  541.     SendPacket(ACTION_SET_DATE,packargs,task);
  542.     UnLock(dirlock);
  543.     FreeMem(ptr,65L);
  544.     }
  545. return 0;
  546. }
  547.  
  548. do_addbuffers()
  549. {
  550. long packargs[7];
  551. long n;
  552. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  553.  
  554. if (!task) { ierror(av[1],510); return 20; }
  555. Errno=0;
  556. n=myatol(av[2]);
  557. if (Errno) return 20;
  558. packargs[0]=n;
  559. SendPacket(ACTION_MORE_CACHE,packargs,task);
  560. return 0;
  561. }
  562.  
  563. do_relabel()
  564. {
  565. long packargs[7];
  566. UBYTE *ptr;
  567. long n;
  568. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  569.  
  570. if (!task) { ierror(av[1],510); return 20; }
  571. ptr=AllocMem(65L,MEMF_PUBLIC);
  572. CtoBStr(av[2],(ULONG)ptr >> 2L,64L);
  573. packargs[0]=(ULONG)ptr >> 2L;
  574. SendPacket(ACTION_RENAME_DISK,packargs,task);
  575. packargs[0]=1L;
  576. SendPacket(ACTION_INHIBIT,packargs,task);
  577. packargs[0]=0L;
  578. SendPacket(ACTION_INHIBIT,packargs,task);
  579. FreeMem(ptr,65L);
  580. }
  581.  
  582. do_diskchange()
  583. {
  584. long packargs[7];
  585. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  586.  
  587. if (!task) { ierror(av[1],510); return 20; }
  588. packargs[0]=1L;
  589. SendPacket(ACTION_INHIBIT,packargs,task);
  590. packargs[0]=0L;
  591. SendPacket(ACTION_INHIBIT,packargs,task);
  592. }
  593.