i386/junos/MIT/src.xv6/sh.c

   1 // Shell.
   2
   3 #include "types.h"
   4 #include "user.h"
   5 #include "fcntl.h"
   6
   7 // Parsed command representation
   8 #define EXEC  1
   9 #define REDIR 2
  10 #define PIPE  3
  11 #define LIST  4
  12 #define BACK  5
  13
  14 #define MAXARGS 10
  15
  16 struct cmd {
  17   int type;
  18 };
  19
  20 struct execcmd {
  21   int type;
  22   char *argv[MAXARGS];
  23   char *eargv[MAXARGS];
  24 };
  25
  26 struct redircmd {
  27   int type;
  28   struct cmd *cmd;
  29   char *file;
  30   char *efile;
  31   int mode;
  32   int fd;
  33 };
  34
  35 struct pipecmd {
  36   int type;
  37   struct cmd *left;
  38   struct cmd *right;
  39 };
  40
  41 struct listcmd {
  42   int type;
  43   struct cmd *left;
  44   struct cmd *right;
  45 };
  46
  47 struct backcmd {
  48   int type;
  49   struct cmd *cmd;
  50 };
  51
  52 int fork1(void);  // Fork but panics on failure.
  53 void panic(char*);
  54 struct cmd *parsecmd(char*);
  55
  56 // Execute cmd.  Never returns.
  57 void
  58 runcmd(struct cmd *cmd)
  59 {
  60   int p[2];
  61   struct backcmd *bcmd;
  62   struct execcmd *ecmd;
  63   struct listcmd *lcmd;
  64   struct pipecmd *pcmd;
  65   struct redircmd *rcmd;
  66
  67   if(cmd == 0)
  68     exit();
  69
  70   switch(cmd->type){
  71   default:
  72     panic("runcmd");
  73
  74   case EXEC:
  75     ecmd = (struct execcmd*)cmd;
  76     if(ecmd->argv[0] == 0)
  77       exit();
  78     exec(ecmd->argv[0], ecmd->argv);
  79     printf(2, "exec %s failed\n", ecmd->argv[0]);
  80     break;
  81
  82   case REDIR:
  83     rcmd = (struct redircmd*)cmd;
  84     close(rcmd->fd);
  85     if(open(rcmd->file, rcmd->mode) < 0){
  86       printf(2, "open %s failed\n", rcmd->file);
  87       exit();
  88     }
  89     runcmd(rcmd->cmd);
  90     break;
  91
  92   case LIST:
  93     lcmd = (struct listcmd*)cmd;
  94     if(fork1() == 0)
  95       runcmd(lcmd->left);
  96     wait();
  97     runcmd(lcmd->right);
  98     break;
  99
 100   case PIPE:
 101     pcmd = (struct pipecmd*)cmd;
 102     if(pipe(p) < 0)
 103       panic("pipe");
 104     if(fork1() == 0){
 105       close(1);
 106       dup(p[1]);
 107       close(p[0]);
 108       close(p[1]);
 109       runcmd(pcmd->left);
 110     }
 111     if(fork1() == 0){
 112       close(0);
 113       dup(p[0]);
 114       close(p[0]);
 115       close(p[1]);
 116       runcmd(pcmd->right);
 117     }
 118     close(p[0]);
 119     close(p[1]);
 120     wait();
 121     wait();
 122     break;
 123
 124   case BACK:
 125     bcmd = (struct backcmd*)cmd;
 126     if(fork1() == 0)
 127       runcmd(bcmd->cmd);
 128     break;
 129   }
 130   exit();
 131 }
 132
 133 int
 134 getcmd(char *buf, int nbuf)
 135 {
 136   printf(2, "$ ");
 137   memset(buf, 0, nbuf);
 138   gets(buf, nbuf);
 139   if(buf[0] == 0) // EOF
 140     return -1;
 141   return 0;
 142 }
 143
 144 int
 145 main(void)
 146 {
 147   static char buf[100];
 148   int fd;
 149
 150   // Assumes three file descriptors open.
 151   while((fd = open("console", O_RDWR)) >= 0){
 152     if(fd >= 3){
 153       close(fd);
 154       break;
 155     }
 156   }
 157
 158   // Read and run input commands.
 159   while(getcmd(buf, sizeof(buf)) >= 0){
 160     if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
 161       // Clumsy but will have to do for now.
 162       // Chdir has no effect on the parent if run in the child.
 163       buf[strlen(buf)-1] = 0;  // chop \n
 164       if(chdir(buf+3) < 0)
 165         printf(2, "cannot cd %s\n", buf+3);
 166       continue;
 167     }
 168     if(fork1() == 0)
 169       runcmd(parsecmd(buf));
 170     wait();
 171   }
 172   exit();
 173 }
 174
 175 void
 176 panic(char *s)
 177 {
 178   printf(2, "%s\n", s);
 179   exit();
 180 }
 181
 182 int
 183 fork1(void)
 184 {
 185   int pid;
 186
 187   pid = fork();
 188   if(pid == -1)
 189     panic("fork");
 190   return pid;
 191 }
 192
 193 //PAGEBREAK!
 194 // Constructors
 195
 196 struct cmd*
 197 execcmd(void)
 198 {
 199   struct execcmd *cmd;
 200
 201   cmd = malloc(sizeof(*cmd));
 202   memset(cmd, 0, sizeof(*cmd));
 203   cmd->type = EXEC;
 204   return (struct cmd*)cmd;
 205 }
 206
 207 struct cmd*
 208 redircmd(struct cmd *subcmd, char *file, char *efile, int mode, int fd)
 209 {
 210   struct redircmd *cmd;
 211
 212   cmd = malloc(sizeof(*cmd));
 213   memset(cmd, 0, sizeof(*cmd));
 214   cmd->type = REDIR;
 215   cmd->cmd = subcmd;
 216   cmd->file = file;
 217   cmd->efile = efile;
 218   cmd->mode = mode;
 219   cmd->fd = fd;
 220   return (struct cmd*)cmd;
 221 }
 222
 223 struct cmd*
 224 pipecmd(struct cmd *left, struct cmd *right)
 225 {
 226   struct pipecmd *cmd;
 227
 228   cmd = malloc(sizeof(*cmd));
 229   memset(cmd, 0, sizeof(*cmd));
 230   cmd->type = PIPE;
 231   cmd->left = left;
 232   cmd->right = right;
 233   return (struct cmd*)cmd;
 234 }
 235
 236 struct cmd*
 237 listcmd(struct cmd *left, struct cmd *right)
 238 {
 239   struct listcmd *cmd;
 240
 241   cmd = malloc(sizeof(*cmd));
 242   memset(cmd, 0, sizeof(*cmd));
 243   cmd->type = LIST;
 244   cmd->left = left;
 245   cmd->right = right;
 246   return (struct cmd*)cmd;
 247 }
 248
 249 struct cmd*
 250 backcmd(struct cmd *subcmd)
 251 {
 252   struct backcmd *cmd;
 253
 254   cmd = malloc(sizeof(*cmd));
 255   memset(cmd, 0, sizeof(*cmd));
 256   cmd->type = BACK;
 257   cmd->cmd = subcmd;
 258   return (struct cmd*)cmd;
 259 }
 260 //PAGEBREAK!
 261 // Parsing
 262
 263 char whitespace[] = " \t\r\n\v";
 264 char symbols[] = "<|>&;()";
 265
 266 int
 267 gettoken(char **ps, char *es, char **q, char **eq)
 268 {
 269   char *s;
 270   int ret;
 271
 272   s = *ps;
 273   while(s < es && strchr(whitespace, *s))
 274     s++;
 275   if(q)
 276     *q = s;
 277   ret = *s;
 278   switch(*s){
 279   case 0:
 280     break;
 281   case '|':
 282   case '(':
 283   case ')':
 284   case ';':
 285   case '&':
 286   case '<':
 287     s++;
 288     break;
 289   case '>':
 290     s++;
 291     if(*s == '>'){
 292       ret = '+';
 293       s++;
 294     }
 295     break;
 296   default:
 297     ret = 'a';
 298     while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
 299       s++;
 300     break;
 301   }
 302   if(eq)
 303     *eq = s;
 304
 305   while(s < es && strchr(whitespace, *s))
 306     s++;
 307   *ps = s;
 308   return ret;
 309 }
 310
 311 int
 312 peek(char **ps, char *es, char *toks)
 313 {
 314   char *s;
 315
 316   s = *ps;
 317   while(s < es && strchr(whitespace, *s))
 318     s++;
 319   *ps = s;
 320   return *s && strchr(toks, *s);
 321 }
 322
 323 struct cmd *parseline(char**, char*);
 324 struct cmd *parsepipe(char**, char*);
 325 struct cmd *parseexec(char**, char*);
 326 struct cmd *nulterminate(struct cmd*);
 327
 328 struct cmd*
 329 parsecmd(char *s)
 330 {
 331   char *es;
 332   struct cmd *cmd;
 333
 334   es = s + strlen(s);
 335   cmd = parseline(&s, es);
 336   peek(&s, es, "");
 337   if(s != es){
 338     printf(2, "leftovers: %s\n", s);
 339     panic("syntax");
 340   }
 341   nulterminate(cmd);
 342   return cmd;
 343 }
 344
 345 struct cmd*
 346 parseline(char **ps, char *es)
 347 {
 348   struct cmd *cmd;
 349
 350   cmd = parsepipe(ps, es);
 351   while(peek(ps, es, "&")){
 352     gettoken(ps, es, 0, 0);
 353     cmd = backcmd(cmd);
 354   }
 355   if(peek(ps, es, ";")){
 356     gettoken(ps, es, 0, 0);
 357     cmd = listcmd(cmd, parseline(ps, es));
 358   }
 359   return cmd;
 360 }
 361
 362 struct cmd*
 363 parsepipe(char **ps, char *es)
 364 {
 365   struct cmd *cmd;
 366
 367   cmd = parseexec(ps, es);
 368   if(peek(ps, es, "|")){
 369     gettoken(ps, es, 0, 0);
 370     cmd = pipecmd(cmd, parsepipe(ps, es));
 371   }
 372   return cmd;
 373 }
 374
 375 struct cmd*
 376 parseredirs(struct cmd *cmd, char **ps, char *es)
 377 {
 378   int tok;
 379   char *q, *eq;
 380
 381   while(peek(ps, es, "<>")){
 382     tok = gettoken(ps, es, 0, 0);
 383     if(gettoken(ps, es, &q, &eq) != 'a')
 384       panic("missing file for redirection");
 385     switch(tok){
 386     case '<':
 387       cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
 388       break;
 389     case '>':
 390       cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
 391       break;
 392     case '+':  // >>
 393       cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
 394       break;
 395     }
 396   }
 397   return cmd;
 398 }
 399
 400 struct cmd*
 401 parseblock(char **ps, char *es)
 402 {
 403   struct cmd *cmd;
 404
 405   if(!peek(ps, es, "("))
 406     panic("parseblock");
 407   gettoken(ps, es, 0, 0);
 408   cmd = parseline(ps, es);
 409   if(!peek(ps, es, ")"))
 410     panic("syntax - missing )");
 411   gettoken(ps, es, 0, 0);
 412   cmd = parseredirs(cmd, ps, es);
 413   return cmd;
 414 }
 415
 416 struct cmd*
 417 parseexec(char **ps, char *es)
 418 {
 419   char *q, *eq;
 420   int tok, argc;
 421   struct execcmd *cmd;
 422   struct cmd *ret;
 423
 424   if(peek(ps, es, "("))
 425     return parseblock(ps, es);
 426
 427   ret = execcmd();
 428   cmd = (struct execcmd*)ret;
 429
 430   argc = 0;
 431   ret = parseredirs(ret, ps, es);
 432   while(!peek(ps, es, "|)&;")){
 433     if((tok=gettoken(ps, es, &q, &eq)) == 0)
 434       break;
 435     if(tok != 'a')
 436       panic("syntax");
 437     cmd->argv[argc] = q;
 438     cmd->eargv[argc] = eq;
 439     argc++;
 440     if(argc >= MAXARGS)
 441       panic("too many args");
 442     ret = parseredirs(ret, ps, es);
 443   }
 444   cmd->argv[argc] = 0;
 445   cmd->eargv[argc] = 0;
 446   return ret;
 447 }
 448
 449 // NUL-terminate all the counted strings.
 450 struct cmd*
 451 nulterminate(struct cmd *cmd)
 452 {
 453   int i;
 454   struct backcmd *bcmd;
 455   struct execcmd *ecmd;
 456   struct listcmd *lcmd;
 457   struct pipecmd *pcmd;
 458   struct redircmd *rcmd;
 459
 460   if(cmd == 0)
 461     return 0;
 462
 463   switch(cmd->type){
 464   case EXEC:
 465     ecmd = (struct execcmd*)cmd;
 466     for(i=0; ecmd->argv[i]; i++)
 467       *ecmd->eargv[i] = 0;
 468     break;
 469
 470   case REDIR:
 471     rcmd = (struct redircmd*)cmd;
 472     nulterminate(rcmd->cmd);
 473     *rcmd->efile = 0;
 474     break;
 475
 476   case PIPE:
 477     pcmd = (struct pipecmd*)cmd;
 478     nulterminate(pcmd->left);
 479     nulterminate(pcmd->right);
 480     break;
 481
 482   case LIST:
 483     lcmd = (struct listcmd*)cmd;
 484     nulterminate(lcmd->left);
 485     nulterminate(lcmd->right);
 486     break;
 487
 488   case BACK:
 489     bcmd = (struct backcmd*)cmd;
 490     nulterminate(bcmd->cmd);
 491     break;
 492   }
 493   return cmd;
 494 }