sh.c

#include "types.h"
#include "stat.h"
#include "user.h"
#include "fs.h"
#include "fcntl.h"

#define BUFSIZ  512
#define MAXARGS  10
#define MAXNODE 2
#define MAXCMD  2

// an embarrassingly naive shell

// some day a real parse tree; for now ad-hoc
struct ionode {
  int token;
  char *s;
};
struct ionode iolist[MAXNODE];
int nextio;

struct cmd {
  char *argv[MAXARGS];
  char argv0buf[BUFSIZ];
  int argc;
  int token;
};
struct cmd cmdlist[MAXCMD]; 
int nextcmd;

char buf[BUFSIZ];
int debug = 0;

int parse(char *s);
void runcmd(void);
int ioredirection(void);
int gettoken(char *s, char **token);
int _gettoken(char *s, char **p1, char **p2);
void addio(int token, char *s);

int
main(void)
{
  while(1){
    puts("$ ");
    memset (buf, '\0', sizeof(buf));
    gets(buf, sizeof(buf));
    if (parse(buf) < 0)
      continue;
    runcmd();
  }
}

int 
parse(char *s)
{
  char *t;
  int c, i;

  gettoken(s, 0);

  nextio = 0;
  nextcmd = 0;
  for (i = 0; i < MAXCMD; i++) {
    cmdlist[i].argc = 0;
    cmdlist[i].token = 0;
  }
  while (1) {
    switch ((c = gettoken(0, &t))) {

    case 'w':	// Add an argument
      if (cmdlist[nextcmd].argc >= MAXARGS) {
	printf(2, "too many arguments\n");
	return -1;
      }
      cmdlist[nextcmd].argv[cmdlist[nextcmd].argc++] = t;
      break;
			
    case '<':	// Input redirection
      // Grab the filename from the argument list
      if (gettoken(0, &t) != 'w') {
	printf(2, "syntax error: < not followed by word\n");
	return -1;
      }
      addio('<', t);
      break;
			
    case '>':	// Output redirection
      // Grab the filename from the argument list
      if (gettoken(0, &t) != 'w') {
	printf(2, "syntax error: > not followed by word\n");
	return -1;
      }
      addio('>', t);
      break;

    case ';':  // command sequence
    case '|':  // pipe
      cmdlist[nextcmd].token = c;
      nextcmd++;
      break;

    case 0:		// String is complete
      return 0;
			
    default:
      printf(2, "syntax error: bad return %d from gettoken", c);
      return -1;
			
    }
  }
}


void
runcmd(void)
{
  int c, i, r, pid, tfd;
  int fdarray[2];

  // Return immediately if command line was empty.
  if(cmdlist[0].argc == 0) {
    if (debug)
      printf(2, "EMPTY COMMAND\n");
    return;
  }

  for (c = 0; c <= nextcmd; c++) {
    // Clean up command line.
    // Read all commands from the filesystem: add an initial '/' to
    // the command name.
    // This essentially acts like 'PATH=/'.
    if (cmdlist[c].argv[0][0] != '/') {
      cmdlist[c].argv0buf[0] = '/';
      strcpy(cmdlist[c].argv0buf + 1, cmdlist[c].argv[0]);
      cmdlist[c].argv[0] = cmdlist[c].argv0buf;
    }
    cmdlist[c].argv[cmdlist[c].argc] = 0;
	
    // Print the command.
    if (debug) {
      printf(2, "[%d] SPAWN:", getpid());
      for (i = 0; cmdlist[c].argv[i]; i++)
	printf(2, " %s", cmdlist[c].argv[i]);
      for (i = 0; i < nextio; i++) {
	printf(2, "%c %s", iolist[i].token, iolist[i].s);
      }
      printf(2, "\n");
    }

    if (strcmp(cmdlist[c].argv[0], "/cd") == 0) {
      if (debug) printf (2, "/cd %s is build in\n", cmdlist[c].argv[1]);
      chdir(cmdlist[c].argv[1]);
      return;
    }

    if (cmdlist[c].token == '|')
      if (pipe(fdarray) < 0)
	printf(2, "cmd %d pipe failed\n", c);

    pid = fork();
    if (pid == 0) {
      if (cmdlist[c].token == '|') {
	if (close(1) < 0) 
	  printf(2, "close 1 failed\n");
	if ((tfd = dup(fdarray[1])) < 0)
	  printf(2, "dup failed\n");
	if (close(fdarray[0]) < 0)
	  printf(2, "close fdarray[0] failed\n");
	if (close(fdarray[1]) < 0)
	  printf(2, "close fdarray[1] failed\n");
      }
      if (c > 0 && cmdlist[c-1].token == '|') {
	if (close(0) < 0) 
	  printf(2, "close 0 failed\n");
	if ((tfd = dup(fdarray[0])) < 0)
	  printf(2, "dup failed\n");
	if (close(fdarray[0]) < 0)
	  printf(2, "close fdarray[0] failed\n");
	if (close(fdarray[1]) < 0)
	  printf(2, "close fdarray[1] failed\n");
      }
      if (ioredirection() < 0)
	exit();
      if ((r = exec(cmdlist[c].argv0buf, (char**) cmdlist[c].argv)) < 0) {
	printf(2, "exec %s: %d\n", cmdlist[c].argv[0], r);
	exit();
      }
    } else if (pid > 0) {
      int p;
      if (debug)
	printf(2, "[%d] FORKED child %d\n", getpid(), pid);

      if (c > 0 && cmdlist[c-1].token == '|') {
	close(fdarray[0]);
	close(fdarray[1]);
      }
      if (cmdlist[c].token != '|') {
	if (debug)
	  printf(2, "[%d] WAIT for children\n", getpid());
	do {
	  p = wait();
	  if (debug)
	    printf(2, "[%d] WAIT child %d finished\n", getpid(), p);
	} while (p > 0);
	if (debug)
	  printf(2, "[%d] wait finished\n", getpid());
      }
    }
  }
}

int
ioredirection(void)
{
  int i, fd;

  for (i = 0; i < nextio; i++) {
    switch (iolist[i].token) {
    case '<':
      if (close(0) < 0)
	printf(2, "close 0 failed\n");
      if ((fd = open(iolist[i].s, O_RDONLY)) < 0) {
	printf(2, "failed to open %s for read: %d", iolist[i].s, fd);
	return -1;
      }
      if (debug)
	printf(2, "redirect 0 from %s\n", iolist[i].s);
      break;
    case '>':
      if (close(1) < 0)
	printf(2, "close 1 failed\n");
      if ((fd = open(iolist[i].s, O_WRONLY|O_CREATE)) < 0) {
	printf(2, "failed to open %s for write: %d", iolist[i].s, fd);
	exit();
      }
      if (debug)
	printf(2, "redirect 1 to %s\n", iolist[i].s);
      break;
    }
  }
  return 0;
}

void
addio(int token, char *s)
{
  if (nextio >= MAXNODE) {
    printf(2, "addio: ran out of nodes\n");
    return;
  }
    
  iolist[nextio].token = token;
  iolist[nextio].s = s;
  nextio++;
}


// gettoken(s, 0) prepares gettoken for subsequent calls and returns 0.
// gettoken(0, token) parses a shell token from the previously set string,
// null-terminates that token, stores the token pointer in '*token',
// and returns a token ID (0, '<', '>', '|', or 'w').
// Subsequent calls to 'gettoken(0, token)' will return subsequent
// tokens from the string.

int
gettoken(char *s, char **p1)
{
  static int c, nc;
  static char* np1, *np2;

  if (s) {
    nc = _gettoken(s, &np1, &np2);
    return 0;
  }
  c = nc;
  *p1 = np1;
  nc = _gettoken(np2, &np1, &np2);
  return c;
}


// Get the next token from string s.
// Set *p1 to the beginning of the token and *p2 just past the token.
// Returns
//	0 for end-of-string;
//	< for <;
//	> for >;
//	| for |;
//	w for a word.
//
// Eventually (once we parse the space where the \0 will go),
// words get nul-terminated.
#define WHITESPACE " \t\r\n"
#define SYMBOLS "<|>&;()"

int
_gettoken(char *s, char **p1, char **p2)
{
  int t;

  if (s == 0) {
    if (debug > 1)
      printf(2, "GETTOKEN NULL\n");
    return 0;
  }

  if (debug > 1)
    printf(2, "GETTOKEN: %s\n", s);

  *p1 = 0;
  *p2 = 0;

  while (strchr(WHITESPACE, *s))
    *s++ = 0;
  if (*s == 0) {
    if (debug > 1)
      printf(2, "EOL\n");
    return 0;
  }
  if (strchr(SYMBOLS, *s)) {
    t = *s;
    *p1 = s;
    *s++ = 0;
    *p2 = s;
    if (debug > 1)
      printf(2, "TOK %c\n", t);
    return t;
  }
  *p1 = s;
  while (*s && !strchr(WHITESPACE SYMBOLS, *s))
    s++;
  *p2 = s;
  if (debug > 1) {
    t = **p2;
    **p2 = 0;
    printf(2, "WORD: %s\n", *p1);
    **p2 = t;
  }
  return 'w';
}