# 2.11BSD#431 - /usr/src/usr.bin/learn/mysys.c

##### Functions

    chgenv            X
    getargs           X
    mysys             X
    system            X

##### Variables

    envp              X

##### Macros

    EASY              X
    EMAX              X
    HARD              X
    MEDIUM            X

       1: #ifndef lint
       2: static char sccsid[] = "@(#)mysys.c	4.5	(Berkeley)	5/15/86";
       3: #endif not lint
       4:
       5: #include "stdio.h"
       6: #include "signal.h"
       7:
       8: #define EASY    1
       9: #define MEDIUM  2
      10: #define HARD    3
      11: #define EMAX    256
      12:
      13: char *envp[EMAX+1];
      14:
      15: /*
      16:  * This routine edits the PATH environment variable so that
      17:  * special commands that learners may need will be found.
      18:  * EXINIT is modified so that the editor will always prompt,
      19:  * will not print \r's, and will be usable with open mode.
      20:  */
      21:
      22: chgenv()
      23: {
      24:     register char **p;
      25:     register int i;
      26:     extern char **environ;
      27:     extern char *direct;
      28:     char path[BUFSIZ], exinit[BUFSIZ];
      29:     char *malloc();
      30:
      31:     sprintf(path, "PATH=%s/bin:/usr/cc/bin:/usr/ucb/bin:", direct);
      32:     sprintf(exinit, "EXINIT=set prompt noopt open window=23");
      33: #if BSD4_2
      34:     system("stty old");
      35:     for (p=environ,i=3; *p != 0 && i < EMAX; p++,i++)   {
      36: #else
      37:     for (p=environ,i=2; *p != 0 && i < EMAX; p++,i++)   {
      38: #endif
      39:         envp[i] = *p;
      40:         if (**p != 'P' && **p != 'E')
      41:             continue;
      42:         if (strncmp(*p, "PATH=", 5) == 0)
      43:             sprintf(path, "PATH=%s/bin:%s", direct, &envp[i--][5]);
      44:         else if (strncmp(*p, "EXINIT=", 7) == 0)
      45:             sprintf(exinit, "%s|set prompt noopt open window=23", envp[i--]);
      46: #if BSD4_2
      47:         else if (strncmp(*p, "PS1=", 4) == 0)
      48:             i--;
      49:     }
      50:     envp[2] = malloc(7);
      51:     strcpy(envp[2], "PS1=% ");
      52: #else
      53:     }
      54: #endif
      55:     envp[0] = malloc(strlen(path) + 1);
      56:     strcpy(envp[0], path);
      57:     envp[1] = malloc(strlen(exinit) + 1);
      58:     strcpy(envp[1], exinit);
      59:     envp[i] = 0;
      60:     environ = envp;
      61: }
      62:
      63: mysys(s)
      64: char *s;
      65: {
      66:     /* like "system" but rips off "mv", etc.*/
      67:     /* also tries to guess if can get away with exec cmd */
      68:     /* instead of sh cmd */
      69:     char p[300];
      70:     char *np[40];
      71:     register char *t;
      72:     int nv, type, stat;
      73:
      74:     type = EASY;    /* we hope */
      75:     for (t = s; *t && type != HARD; t++) {
      76:         switch (*t) {
      77:         case '*':
      78:         case '[':
      79:         case '?':
      80:         case '>':
      81:         case '<':
      82:         case '$':
      83:         case '\'':
      84:         case '"':
      85:         case '`':
      86:         case '{':
      87:         case '~':
      88:             type = MEDIUM;
      89:             break;
      90:         case '|':
      91:         case ';':
      92:         case '&':
      93:             type = HARD;
      94:             break;
      95:         }
      96:     }
      97:     switch (type) {
      98:     case HARD:
      99:         return(system(s));
     100:     case MEDIUM:
     101:         strcpy(p, "exec ");
     102:         strcat(p, s);
     103:         return(system(p));
     104:     case EASY:
     105:         strcpy(p,s);
     106:         nv = getargs(p, np);
     107:         t=np[0];
     108:         if ((strcmp(t, "mv") == 0)||
     109:             (strcmp(t, "cp") == 0)||
     110:             (strcmp(t, "rm") == 0)||
     111:             (strcmp(t, "ls") == 0) ) {
     112:             if (fork() == 0) {
     113:                 char b[100];
     114:                 signal(SIGINT, SIG_DFL);
     115:                 np[nv] = 0;
     116:                 execvp(t, np);
     117:                 perror(t);
     118:             /*	sprintf(b, "/usr/ucb/bin/%s", t);
     119: 				execv(b, np);
     120: 				sprintf(b, "/usr/ucb/%s", t);
     121: 				execv(b, np);
     122: 				sprintf(b, "/bin/%s", t);
     123: 				execv(b, np);
     124: 				sprintf(b, "/usr/bin/%s", t);
     125: 				execv(b, np);
     126: 				perror(b); */
     127:                 fprintf(stderr, "Mysys:  execv failed on %s\n", np);
     128:                 exit(1);
     129:             }
     130:             wait(&stat);
     131:             return(stat);
     132:         }
     133:         return(system(s));
     134:     }
     135: }
     136:
     137: /*
     138:  * system():
     139:  *	same as library version, except that resets
     140:  *	default handling of signals in child, so that
     141:  *	user gets the behavior he expects.
     142:  */
     143:
     144: system(s)
     145: char *s;
     146: {
     147:     int status, pid, w;
     148:     register int (*istat)(), (*qstat)();
     149:
     150:     istat = signal(SIGINT, SIG_IGN);
     151:     qstat = signal(SIGQUIT, SIG_IGN);
     152:     if ((pid = fork()) == 0) {
     153:         signal(SIGINT, SIG_DFL);
     154:         signal(SIGQUIT, SIG_DFL);
     155:         execl("/bin/csh", "csh", "-cf", s, 0);
     156:         _exit(127);
     157:     }
     158:     while ((w = wait(&status)) != pid && w != -1)
     159:         ;
     160:     if (w == -1)
     161:         status = -1;
     162:     signal(SIGINT, istat);
     163:     signal(SIGQUIT, qstat);
     164:     return(status);
     165: }
     166:
     167: getargs(s, v)
     168: char *s, **v;
     169: {
     170:     int i;
     171:
     172:     i = 0;
     173:     for (;;) {
     174:         v[i++]=s;
     175:         while (*s != 0 && *s!=' '&& *s != '\t')
     176:             s++;
     177:         if (*s == 0)
     178:             break;
     179:         *s++ =0;
     180:         while (*s == ' ' || *s == '\t')
     181:             s++;
     182:         if (*s == 0)
     183:             break;
     184:     }
     185:     return(i);
     186: }

#### Defined functions

chgenv defined in line 22; used 1 times

- in /usr/src/usr.bin/learn/learn.c line 46

getargs defined in line 167; used 1 times

- in line 106

mysys defined in line 63; used 1 times

- in /usr/src/usr.bin/learn/copy.c line 68

system defined in line 144; used 6 times

- in line 34, 99-103(2), 133
- in /usr/src/usr.bin/learn/selsub.c line 114, 123

#### Defined variables

envp defined in line 13; used 11 times

- in line 39-60(11)

sccsid defined in line 2; never used

#### Defined macros

EASY defined in line 8; used 1 times

- in line 74

EMAX defined in line 11; used 3 times

- in line 13, 35-37(2)

HARD defined in line 10; used 2 times

- in line 75, 93

MEDIUM defined in line 9; used 1 times

- in line 88

Last modified: 1986-05-16 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1327 |