sh.c

/*
 * Copyright (c) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009
 *      The President and Fellows of Harvard College.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * sh - shell
 *
 * Usage:
 *     sh
 *     sh -c command
 */

#include <sys/types.h>
#include <sys/wait.h>
#include <assert.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <err.h>

#ifdef HOST
#include "hostcompat.h"
#endif

#ifndef NARG_MAX
/* no NARG_MAX on most unixes */
#define NARG_MAX 1024
#endif

/* avoid making this unreasonably large; causes problems under dumbvm */
#if ARG_MAX > 4096
#define CMDLINE_MAX 4096
#else
#define CMDLINE_MAX ARG_MAX
#endif

/* set to nonzero if __time syscall seems to work */
static int timing = 0;

/* array of backgrounded jobs (allows "foregrounding") */
#define MAXBG 128
static pid_t bgpids[MAXBG];

/*
 * can_bg
 * just checks for an open slot.
 */
static
int
can_bg(void)
{
        int i;
        
        for (i = 0; i < MAXBG; i++) {
                if (bgpids[i] == 0) {
                        return 1;
                }
        }
        
        return 0;
}

/* 
 * remember_bg
 * sticks the pid in an open slot in the background array.  note the assert --
 * better check can_bg before calling this.
 */
static
void
remember_bg(pid_t pid)
{
        int i;
        for (i = 0; i < MAXBG; i++) {
                if (bgpids[i] == 0) {
                        bgpids[i] = pid;
                        return;
                }
        }
        assert(0);
}

/*
 * printstatus
 * print results from wait
 */
static
void
printstatus(int status)
{
        if (WIFEXITED(status)) {
                printf("Exit %d", WEXITSTATUS(status));
        }
        else if (WIFSIGNALED(status) && WCOREDUMP(status)) {
                printf("Signal %d (core dumped)", WTERMSIG(status));
        }
        else if (WIFSIGNALED(status)) {
                printf("Signal %d", WTERMSIG(status));
        }
        else if (WIFSTOPPED(status)) {
                printf("Stopped on signal %d", WSTOPSIG(status));
        }
        else {
                printf("Invalid status code %d", status);
        }
}

/*
 * dowait
 * just does a waitpid.
 */
static
void
dowait(pid_t pid)
{
        int status;
        if (waitpid(pid, &status, 0)<0) {
                warn("pid %d", pid);
        }
        else {
                printf("pid %d: ", pid);
                printstatus(status);
                printf("\n");
        }
}

#ifdef WNOHANG
/*
 * dowaitpoll
 * like dowait, but uses WNOHANG. returns true if we got something.
 */
static
int
dowaitpoll(pid_t pid)
{
        int status;
        pid_t result;
        result = waitpid(pid, &status, WNOHANG);
        if (result<0) {
                warn("pid %d", pid);
        }
        else if (result!=0) {
                printf("pid %d: ", pid);
                printstatus(status);
                printf("\n");
                return 1;
        }
        return 0;
}

/*
 * waitpoll
 * poll all background jobs for having exited.
 */
static
void
waitpoll(void)
{
        int i;
        for (i=0; i < MAXBG; i++) {
                if (bgpids[i] != 0) {
                        if (dowaitpoll(bgpids[i])) {
                                bgpids[i] = 0;
                        }
                }
        }
}
#endif /* WNOHANG */

/*
 * wait
 * allows the user to "foreground" a process by waiting on it.  without ps to
 * know the pids, this is a little tough to use with an arg, but without an
 * arg it will wait for all the background jobs.
 */
static
int
cmd_wait(int ac, char *av[])
{
        int i;
        pid_t pid;

        if (ac == 2) {
                pid = atoi(av[1]);
                dowait(pid);
                for (i = 0; i < MAXBG; i++) {
                        if (bgpids[i]==pid) {
                                bgpids[i] = 0;
                        }
                }
                return 0;
        }
        else if (ac == 1) {
                for (i=0; i < MAXBG; i++) {
                        if (bgpids[i] != 0) {
                                dowait(bgpids[i]);
                                bgpids[i] = 0;
                        }
                }
                return 0;
        }
        printf("Usage: wait [pid]\n");
        return 1;
}

/*
 * chdir
 * just an interface to the system call.  no concept of home directory, so
 * require the directory.
 */
static
int
cmd_chdir(int ac, char *av[])
{
        if (ac == 2) {
                if (chdir(av[1])) {
                        warn("chdir");
                        return 1;
                }
                return 0;
        }
        printf("Usage: chdir dir\n");
        return 1;
}

/*
 * exit
 * pretty simple.  allow the user to choose the exit code if they want,
 * otherwise default to 0 (success).
 */
static
int
cmd_exit(int ac, char *av[])
{
        int code;

        if (ac == 1) {
                code = 0;
        }
        else if (ac == 2) {
                code = atoi(av[1]);
        }
        else {
                printf("Usage: exit [code]\n");
                return 1;
        }
        
        exit(code);
        
        return 0; /* quell the compiler warning */
}

/*
 * a struct of the builtins associates the builtin name with the function that
 * executes it.  they must all take an argc and argv.
 */
static struct {
        const char *name;
        int (*func)(int, char **);
} builtins[] = {
        { "cd",    cmd_chdir },
        { "chdir", cmd_chdir },
        { "exit",  cmd_exit },
        { "wait",  cmd_wait },
        { NULL, NULL }
};

/*
 * docommand
 * tokenizes the command line using strtok.  if there aren't any commands,
 * simply returns.  checks to see if it's a builtin, running it if it is.
 * otherwise, it's a standard command.  check for the '&', try to background
 * the job if possible, otherwise just run it and wait on it.
 */
static
int
docommand(char *buf)
{
        char *args[NARG_MAX + 1];
        int nargs, i;
        char *s;
        pid_t pid;
        int status;
        int bg=0;
        time_t startsecs, endsecs;
        unsigned long startnsecs, endnsecs;

        nargs = 0;
        for (s = strtok(buf, " \t\r\n"); s; s = strtok(NULL, " \t\r\n")) {
                if (nargs >= NARG_MAX) {
                        printf("%s: Too many arguments "
                               "(exceeds system limit)\n",
                               args[0]);
                        return 1;
                }
                args[nargs++] = s;
        }
        args[nargs] = NULL;

        if (nargs==0) {
                /* empty line */
                return 0;
        }

        for (i=0; builtins[i].name; i++) {
                if (!strcmp(builtins[i].name, args[0])) {
                        return builtins[i].func(nargs, args);
                }
        }

        /* Not a builtin; run it */

        if (nargs > 0 && !strcmp(args[nargs-1], "&")) {
                /* background */
                if (!can_bg()) {
                        printf("%s: Too many background jobs; wait for "
                               "some to finish before starting more\n",
                               args[0]);
                        return -1;
                }
                nargs--;
                args[nargs] = NULL;
                bg = 1;
        }

        if (timing) {
                __time(&startsecs, &startnsecs);
        }

        pid = fork();
        switch (pid) {
                case -1:
                        /* error */
                        warn("fork");
                        return _MKWAIT_EXIT(255);
                case 0:
                        /* child */
                        execv(args[0], args);
                        warn("%s", args[0]);
                        /*
                         * Use _exit() instead of exit() in the child
                         * process to avoid calling atexit() functions,
                         * which would cause hostcompat (if present) to
                         * reset the tty state and mess up our input
                         * handling.
                         */
                        _exit(1);
                default:
                        break;
        }

        /* parent */
        if (bg) {
                /* background this command */
                remember_bg(pid);
                printf("[%d] %s ... &\n", pid, args[0]);
                return 0;
        }

        if (waitpid(pid, &status, 0) < 0) {
                warn("waitpid");
                status = -1;
        }

        if (timing) {
                __time(&endsecs, &endnsecs);
                if (endnsecs < startnsecs) {
                        endnsecs += 1000000000;
                        endsecs--;
                }
                endnsecs -= startnsecs;
                endsecs -= startsecs;
                warnx("subprocess time: %lu.%09lu seconds",
                      (unsigned long) endsecs, (unsigned long) endnsecs);
        }

        return status;
}

/*
 * getcmd
 * pulls valid characters off the console, filling the buffer.  
 * backspace deletes a character, simply by moving the position back.
 * a newline or carriage return breaks the loop, which terminates
 * the string and returns.
 *
 * if there's an invalid character or a backspace when there's nothing 
 * in the buffer, putchars an alert (bell).
 */
static
void
getcmd(char *buf, size_t len)
{
        size_t pos = 0;
        int done=0, ch;

        /*
         * In the absence of a <ctype.h>, assume input is 7-bit ASCII.
         */

        while (!done) {
                ch = getchar();
                if ((ch == '\b' || ch == 127) && pos > 0) {
                        putchar('\b');
                        putchar(' ');
                        putchar('\b');
                        pos--;
                }
                else if (ch == '\r' || ch == '\n') {
                        putchar('\r');
                        putchar('\n');
                        done = 1;
                }
                else if (ch >= 32 && ch < 127 && pos < len-1) {
                        buf[pos++] = ch;
                        putchar(ch);
                }
                else {
                        /* alert (bell) character */
                        putchar('\a');
                }
        }
        buf[pos] = 0;
}       

/*
 * interactive
 * runs the interactive shell.  basically, just infinitely loops, grabbing
 * commands and running them (and printing the exit status if it's not
 * success.)
 */
static
void
interactive(void)
{
        char buf[CMDLINE_MAX];
        int status;

        while (1) {
                printf("OS/161$ ");
                getcmd(buf, sizeof(buf));
                status = docommand(buf);
                if (status) {
                        printstatus(status);
                        printf("\n");
                }
#ifdef WNOHANG
                waitpoll();
#endif
        }
}

static
void
check_timing(void)
{
        time_t secs;
        unsigned long nsecs;
        if (__time(&secs, &nsecs) != -1) {
                timing = 1;
                warnx("Timing enabled.");
        }
}

/* 
 * main
 * if there are no arguments, run interactively, otherwise, run a program
 * from within the shell, but immediately exit.
 */
int
main(int argc, char *argv[])
{
#ifdef HOST
        hostcompat_init(argc, argv);
#endif
        check_timing();

        /*
         * Allow argc to be 0 in case we're running on a broken kernel,
         * or one that doesn't set argv when starting the first shell.
         */
        if (argc == 0 || argc == 1) {
                interactive();
        }
        else if (argc == 3 && !strcmp(argv[1], "-c")) {
                return docommand(argv[2]);
        }
        else {
                errx(1, "Usage: sh [-c command]");
        }
        return 0;
}