xv6-65oo2/sh.c

342 lines
7.2 KiB
C
Raw Normal View History

#include "types.h"
#include "stat.h"
#include "user.h"
#include "fs.h"
#include "fcntl.h"
#define BUFSIZ 512
#define MAXARGS 10
2006-09-07 03:16:15 +00:00
#define MAXIO 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 cmd {
char *argv[MAXARGS];
char argv0buf[BUFSIZ];
int argc;
int token;
2006-09-07 03:16:15 +00:00
struct ionode iolist[MAXIO];
struct ionode *io;
};
2006-09-06 17:27:19 +00:00
struct cmd cmdlist[MAXCMD];
struct cmd *cmd;
char buf[BUFSIZ];
2007-08-10 17:00:00 +00:00
int debug;
int parse(char *s);
void runcmd(void);
2007-08-10 17:00:00 +00:00
int getcmd(char *buf, int nbuf);
int ioredirection(struct ionode *iolist, int nio);
int gettoken(char *s, char **token);
int _gettoken(char *s, char **p1, char **p2);
int
main(void)
{
while(getcmd(buf, sizeof(buf)) >= 0) {
2007-08-10 17:00:00 +00:00
if(parse(buf) >= 0)
runcmd();
}
2007-08-08 08:39:07 +00:00
exit();
}
2007-08-10 17:00:00 +00:00
int
getcmd(char *buf, int nbuf)
{
printf(2, "$ ");
2007-08-10 17:00:00 +00:00
memset(buf, 0, nbuf);
gets(buf, nbuf);
if(buf[0] == 0) // EOF
return -1;
return 0;
}
2006-09-06 17:27:19 +00:00
int
parse(char *s)
{
char *t;
int c, i;
gettoken(s, 0);
2007-08-10 17:00:00 +00:00
cmd = &cmdlist[0];
2006-09-06 17:27:19 +00:00
for(i = 0; i < MAXCMD; i++) {
cmdlist[i].argc = 0;
cmdlist[i].token = 0;
cmdlist[i].io = cmdlist[i].iolist;
}
2007-08-10 17:00:00 +00:00
for(;;){
2006-09-06 17:27:19 +00:00
switch((c = gettoken(0, &t))) {
case 'w': // Add an argument
if(cmd->argc >= MAXARGS) {
printf(2, "too many arguments\n");
return -1;
}
cmd->argv[cmd->argc++] = t;
break;
2006-09-06 17:27:19 +00:00
2006-09-07 03:16:15 +00:00
case '>': // Input and output redirection
case '<':
// Grab the filename from the argument list
2006-09-06 17:27:19 +00:00
if(gettoken(0, &t) != 'w') {
2006-09-07 03:16:15 +00:00
printf(2, "syntax error: > not followed by word\n");
return -1;
}
2006-09-07 03:16:15 +00:00
if(cmd->io - cmd->iolist >= MAXIO) {
printf(2, "too many redirections\n");
return -1;
}
2006-09-07 03:16:15 +00:00
cmd->io->token = c;
cmd->io->s = t;
cmd->io++;
break;
case ';': // command sequence
case '|': // pipe
2006-09-07 03:16:15 +00:00
if(cmd->io - cmd->iolist >= MAXIO) {
printf(2, "too many redirections\n");
return -1;
}
cmd->token = c;
cmd++;
break;
case 0: // String is complete
return 0;
2006-09-06 17:27:19 +00:00
default:
printf(2, "syntax error: bad return %d from gettoken", c);
return -1;
2006-09-06 17:27:19 +00:00
}
}
}
void
runcmd(void)
{
int i, r, pid, tfd;
int fdarray[2];
struct cmd *c;
struct ionode *io;
// Return immediately if command line was empty.
if(cmdlist[0].argc == 0) {
2006-09-06 17:27:19 +00:00
if(debug)
printf(2, "EMPTY COMMAND\n");
return;
}
for(c = &cmdlist[0]; c <= cmd; c++) {
// Clean up command line.
// Read all commands from the filesystem: add an initial '/' to
// the command name.
// This essentially acts like 'PATH=/'.
if(c->argv[0][0] != '/') {
c->argv0buf[0] = '/';
strcpy(c->argv0buf + 1, c->argv[0]);
c->argv[0] = c->argv0buf;
}
c->argv[c->argc] = 0;
2006-09-06 17:27:19 +00:00
// Print the command.
2006-09-06 17:27:19 +00:00
if(debug) {
printf(2, "[%d] SPAWN:", getpid());
for(i = 0; c->argv[i]; i++)
printf(2, " %s", c->argv[i]);
for(io = c->iolist; io <= c->io; io++) {
printf(2, "%c %s", io->token, io->s);
}
printf(2, "\n");
}
if(strcmp(c->argv[0], "/cd") == 0) {
2006-09-06 17:57:47 +00:00
if(debug)
printf (2, "/cd %s is build in\n", c->argv[1]);
chdir(c->argv[1]);
return;
}
if(c->token == '|')
2006-09-06 17:27:19 +00:00
if(pipe(fdarray) < 0)
printf(2, "cmd %d pipe failed\n", c);
pid = fork();
2006-09-06 17:27:19 +00:00
if(pid == 0) {
if(c->token == '|') {
2006-09-06 17:27:19 +00:00
if(close(1) < 0)
printf(2, "close 1 failed\n");
2006-09-06 17:27:19 +00:00
if((tfd = dup(fdarray[1])) < 0)
printf(2, "dup failed\n");
2006-09-06 17:27:19 +00:00
if(close(fdarray[0]) < 0)
printf(2, "close fdarray[0] failed\n");
2006-09-06 17:27:19 +00:00
if(close(fdarray[1]) < 0)
printf(2, "close fdarray[1] failed\n");
}
if(c > cmdlist && (c-1)->token == '|') {
2006-09-06 17:27:19 +00:00
if(close(0) < 0)
printf(2, "close 0 failed\n");
2006-09-06 17:27:19 +00:00
if((tfd = dup(fdarray[0])) < 0)
printf(2, "dup failed\n");
2006-09-06 17:27:19 +00:00
if(close(fdarray[0]) < 0)
printf(2, "close fdarray[0] failed\n");
2006-09-06 17:27:19 +00:00
if(close(fdarray[1]) < 0)
printf(2, "close fdarray[1] failed\n");
}
if(ioredirection(c->iolist, c->io - c->iolist) < 0)
exit();
if((r = exec(c->argv0buf, (char**) c->argv)) < 0) {
printf(2, "exec %s: %d\n", c->argv[0], r);
exit();
}
2006-09-06 17:27:19 +00:00
} else if(pid > 0) {
int p;
2006-09-06 17:27:19 +00:00
if(debug)
printf(2, "[%d] FORKED child %d\n", getpid(), pid);
if(c > cmdlist && (c-1)->token == '|') {
close(fdarray[0]);
close(fdarray[1]);
}
if(c->token != '|') {
2006-09-06 17:27:19 +00:00
if(debug)
printf(2, "[%d] WAIT for children\n", getpid());
do {
p = wait();
2006-09-06 17:27:19 +00:00
if(debug)
printf(2, "[%d] WAIT child %d finished\n", getpid(), p);
2006-09-06 17:27:19 +00:00
} while(p > 0);
if(debug)
printf(2, "[%d] wait finished\n", getpid());
}
}
}
}
int
ioredirection(struct ionode *iolist, int nio)
{
int fd;
struct ionode *io;
for(io = iolist; io < &iolist[nio]; io++) {
switch(io->token) {
case '<':
2006-09-06 17:27:19 +00:00
if(close(0) < 0)
printf(2, "close 0 failed\n");
if((fd = open(io->s, O_RDONLY)) < 0) {
printf(2, "failed to open %s for read: %d", io->s, fd);
return -1;
}
2006-09-06 17:27:19 +00:00
if(debug)
printf(2, "redirect 0 from %s\n", io->s);
break;
case '>':
2006-09-06 17:27:19 +00:00
if(close(1) < 0)
printf(2, "close 1 failed\n");
if((fd = open(io->s, O_WRONLY|O_CREATE)) < 0) {
printf(2, "failed to open %s for write: %d", io->s, fd);
exit();
}
2006-09-06 17:27:19 +00:00
if(debug)
printf(2, "redirect 1 to %s\n", io->s);
break;
}
}
return 0;
}
// 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;
2006-09-06 17:27:19 +00:00
static char *np1, *np2;
2006-09-06 17:27:19 +00:00
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;
2006-09-06 17:27:19 +00:00
if(s == 0) {
if(debug > 1)
2006-09-06 18:21:54 +00:00
printf(2, "GETTOKEN 0\n");
return 0;
}
2006-09-06 17:27:19 +00:00
if(debug > 1)
printf(2, "GETTOKEN: %s\n", s);
*p1 = 0;
*p2 = 0;
2006-09-06 17:27:19 +00:00
while(strchr(WHITESPACE, *s))
*s++ = 0;
2006-09-06 17:27:19 +00:00
if(*s == 0) {
if(debug > 1)
printf(2, "EOL\n");
return 0;
}
2006-09-06 17:27:19 +00:00
if(strchr(SYMBOLS, *s)) {
t = *s;
*p1 = s;
*s++ = 0;
*p2 = s;
2006-09-06 17:27:19 +00:00
if(debug > 1)
printf(2, "TOK %c\n", t);
return t;
}
*p1 = s;
2006-09-06 17:27:19 +00:00
while(*s && !strchr(WHITESPACE SYMBOLS, *s))
s++;
*p2 = s;
2006-09-06 17:27:19 +00:00
if(debug > 1) {
t = **p2;
**p2 = 0;
printf(2, "WORD: %s\n", *p1);
**p2 = t;
}
return 'w';
}