2006-08-11 15:55:18 +02:00
|
|
|
#include "types.h"
|
2006-08-14 23:22:13 +02:00
|
|
|
#include "stat.h"
|
|
|
|
#include "user.h"
|
2006-08-11 15:55:18 +02:00
|
|
|
#include "fs.h"
|
|
|
|
#include "fcntl.h"
|
|
|
|
|
2006-08-23 03:09:24 +02:00
|
|
|
#define BUFSIZ 512
|
|
|
|
#define MAXARGS 10
|
|
|
|
#define MAXNODE 2
|
|
|
|
|
|
|
|
// only allocate nodes for i/o redir; at some point we may have to build a
|
|
|
|
// a real parse tree.
|
|
|
|
struct node {
|
|
|
|
int token;
|
|
|
|
char *s;
|
|
|
|
};
|
|
|
|
struct node list[MAXNODE];
|
|
|
|
int nextnode;
|
|
|
|
|
|
|
|
char buf[BUFSIZ];
|
|
|
|
char *argv[MAXARGS];
|
|
|
|
char argv0buf[BUFSIZ];
|
|
|
|
int argc;
|
|
|
|
|
2006-08-29 21:59:52 +02:00
|
|
|
int debug = 0;
|
2006-08-23 03:09:24 +02:00
|
|
|
|
|
|
|
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 addnode(int token, char *s);
|
2006-08-11 15:55:18 +02:00
|
|
|
|
|
|
|
int
|
|
|
|
main(void)
|
|
|
|
{
|
|
|
|
while(1){
|
2006-08-12 13:38:57 +02:00
|
|
|
puts("$ ");
|
2006-08-20 01:41:34 +02:00
|
|
|
memset (buf, '\0', sizeof(buf));
|
2006-08-11 15:55:18 +02:00
|
|
|
gets(buf, sizeof(buf));
|
2006-08-23 03:09:24 +02:00
|
|
|
if (parse(buf) < 0)
|
2006-08-11 15:55:18 +02:00
|
|
|
continue;
|
2006-08-23 03:09:24 +02:00
|
|
|
runcmd();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
parse(char *s)
|
|
|
|
{
|
|
|
|
char *t;
|
|
|
|
int c;
|
|
|
|
|
|
|
|
gettoken(s, 0);
|
|
|
|
|
|
|
|
argc = 0;
|
|
|
|
nextnode = 0;
|
|
|
|
while (1) {
|
|
|
|
switch ((c = gettoken(0, &t))) {
|
|
|
|
|
|
|
|
case 'w': // Add an argument
|
|
|
|
if (argc == MAXARGS) {
|
|
|
|
printf(2, "too many arguments\n");
|
|
|
|
return -1;
|
2006-08-20 01:41:34 +02:00
|
|
|
}
|
2006-08-23 03:09:24 +02:00
|
|
|
argv[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;
|
|
|
|
}
|
|
|
|
addnode('<', 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;
|
|
|
|
}
|
|
|
|
addnode('>', t);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0: // String is complete
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
default:
|
|
|
|
printf(2, "syntax error: bad return %d from gettoken", c);
|
|
|
|
return -1;
|
|
|
|
|
2006-08-11 15:55:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-08-14 23:22:13 +02:00
|
|
|
|
2006-08-23 03:09:24 +02:00
|
|
|
|
2006-08-14 23:22:13 +02:00
|
|
|
void
|
2006-08-23 03:09:24 +02:00
|
|
|
runcmd(void)
|
|
|
|
{
|
|
|
|
int i, r, pid;
|
|
|
|
|
|
|
|
// Return immediately if command line was empty.
|
|
|
|
if(argc == 0) {
|
|
|
|
if (debug)
|
|
|
|
printf(2, "EMPTY COMMAND\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Clean up command line.
|
|
|
|
// Read all commands from the filesystem: add an initial '/' to
|
|
|
|
// the command name.
|
|
|
|
// This essentially acts like 'PATH=/'.
|
|
|
|
if (argv[0][0] != '/') {
|
|
|
|
argv0buf[0] = '/';
|
|
|
|
strcpy(argv0buf + 1, argv[0]);
|
|
|
|
argv[0] = argv0buf;
|
|
|
|
}
|
|
|
|
argv[argc] = 0;
|
|
|
|
|
|
|
|
// Print the command.
|
|
|
|
if (debug) {
|
|
|
|
printf(2, "[%d] SPAWN:", getpid());
|
|
|
|
for (i = 0; argv[i]; i++)
|
|
|
|
printf(2, " %s", argv[i]);
|
|
|
|
for (i = 0; i < nextnode; i++) {
|
|
|
|
printf(2, "%c %s", list[i].token, list[i].s);
|
|
|
|
}
|
|
|
|
printf(2, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(argv[0], "/cd") == 0) {
|
|
|
|
if (debug) printf (2, "/cd %s is build in\n", argv[1]);
|
|
|
|
chdir(argv[1]);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pid = fork();
|
|
|
|
if (pid == 0) {
|
|
|
|
if (ioredirection() < 0)
|
|
|
|
exit();
|
|
|
|
if ((r = exec(argv0buf, (char**) argv)) < 0) {
|
|
|
|
printf(2, "exec %s: %d\n", argv[0], r);
|
|
|
|
exit();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pid > 0) {
|
|
|
|
if (debug)
|
|
|
|
printf(2, "[%d] WAIT %s\n", getpid(), argv[0]);
|
|
|
|
wait();
|
|
|
|
if (debug)
|
|
|
|
printf(2, "[%d] wait finished\n", getpid());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ioredirection(void)
|
2006-08-14 23:22:13 +02:00
|
|
|
{
|
2006-08-23 03:09:24 +02:00
|
|
|
int i, fd, dfd;
|
|
|
|
|
|
|
|
for (i = 0; i < nextnode; i++) {
|
|
|
|
switch (list[i].token) {
|
|
|
|
case '<':
|
|
|
|
if ((fd = open(list[i].s, O_RDONLY)) < 0) {
|
|
|
|
printf(2, "failed to open %s for read: %d", list[i].s, fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (debug)
|
|
|
|
printf(2, "redirect 0 from %s\n", list[i].s);
|
|
|
|
|
|
|
|
close(0);
|
|
|
|
if ((dfd = dup(fd)) < 0)
|
|
|
|
printf(2, "dup failed\n");
|
|
|
|
if (debug)
|
|
|
|
printf(2, "dup returns %d\n", dfd);
|
|
|
|
close(fd);
|
|
|
|
break;
|
|
|
|
case '>':
|
|
|
|
if ((fd = open(list[i].s, O_WRONLY|O_CREATE)) < 0) {
|
|
|
|
printf(2, "failed to open %s for write: %d", list[i].s, fd);
|
2006-08-14 23:22:13 +02:00
|
|
|
exit();
|
|
|
|
}
|
2006-08-23 03:09:24 +02:00
|
|
|
|
|
|
|
if (debug)
|
|
|
|
printf(2, "redirect 1 to %s\n", list[i].s);
|
|
|
|
|
|
|
|
if (close(1) < 0)
|
|
|
|
printf(2, "close 1 failed\n");
|
|
|
|
if ((dfd = dup(fd)) < 0)
|
|
|
|
printf(2, "dup failed\n");
|
|
|
|
if (debug)
|
|
|
|
printf(2, "dup returns %d\n", dfd);
|
|
|
|
close(fd);
|
|
|
|
break;
|
2006-08-14 23:22:13 +02:00
|
|
|
}
|
|
|
|
}
|
2006-08-23 03:09:24 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
addnode(int token, char *s)
|
|
|
|
{
|
|
|
|
if (nextnode >= MAXNODE) {
|
|
|
|
printf(2, "addnode: ran out of nodes\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
list[nextnode].token = token;
|
|
|
|
list[nextnode].s = s;
|
|
|
|
nextnode++;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// 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;
|
2006-08-14 23:22:13 +02:00
|
|
|
}
|
2006-08-23 03:09:24 +02:00
|
|
|
|
|
|
|
|
|
|
|
// 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';
|
|
|
|
}
|
|
|
|
|