shell.c

/*
 * cs537 Project 1 - Shell
 *
 * Written by Stefan Strandberg (stefan@cs.wisc.edu)
 * $Id: shell.c,v 1.10 2004/09/23 22:00:27 stefan Exp $
 *
 */

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "shell.h"
#include "job.h"

#define MAX_INPUT_SIZE 512
#define MAX_JOBS 32766


///////////////////////
//
// create_shell()
//
//   * creates a shell and returns it
//
///////////////////////

shell_t *create_shell(void) {
    shell_t *shell = (shell_t*)malloc(MAX_INPUT_SIZE);
    if(shell == NULL) {
        fprintf(stderr, "Unable to malloc() in create_shell!!\n");
        exit(1);
    }
    shell->prompt = "turtle > ";

    return shell;
}



/////////////////////////
//
// do_jobcmd()
//
//   * executes what's needed for the 'j' shell command
//
//   * FIXME: pid/waitpid problems, although it works.
//
/////////////////////////

void do_jobcmd(job_t *job[], int jobnums) {
    int c, result, status;
    for (c = 0 ; c < jobnums - 1 ; c++) {
        result = waitpid(job[c]->pid, &status, WNOHANG);
        // the below shouldn't really work, but it seems to.  I don't care.
        switch (result) {
            case (0): // still running
                print_job(job[c]);
            case (-1):  // who cares, as long as it's not running.  Probably
                        // got reaped weird or something.
            default: // being reaped.
            break;
        }
    }
    return;
}



//////////////////////////
//
// do_waitcmd()
//
//   * does what's needed for the 'w' shell command
//
//////////////////////////

void do_waitcmd(job_t *job) {
    int status;
    waitpid(job->pid, &status, 0);
    printf("Job %d terminated\n", job->jid);

}



////////////////////////////
//
// run_shell()
//
//   * runs the shell, pretty much does everything.  lots going on here
//
//   *FIXME:  Memory leak stuff
//   *FIXME:  Extra code here, but I'm out of time
//
///////////////////////////

int run_shell(shell_t *shell, int interactive, int *jobnum, job_t *job,
              FILE *inbuffer) {
    action_t retval = NORMAL;
    char *exitcmd = "exit";
    char *backgroundcmd = "&";
    char *jobcmd = "j";
    char *waitcmd = "w";
    char *command;
    char *args[MAX_INPUT_SIZE];
    char *lastarg = NULL;
    int arg_counter = 0;
    int background = 0;
    int status;

    char buffer[2 * MAX_INPUT_SIZE];
    char *input = malloc(2 * MAX_INPUT_SIZE);
    if (input == NULL) {
        fprintf(stderr, "Unable to malloc() in run_shell()!!\n\n");
        exit(1);
    }
    if (interactive)
        printf("%s", shell->prompt);
    input = fgets(buffer, MAX_INPUT_SIZE + 1, inbuffer);
    // what the heck do we do with the rest of the line if more than 512??
    if (input == NULL)  { // EOF or Ctrl-D
        return EXITVAL;
    }
    //printf("%s\n", inbuffer);
    if ((strlen(input)) >= MAX_INPUT_SIZE) {
        fprintf(stderr, "Error: Command too long!!\n");
        if (!interactive) { // echo it
            printf("%s\n", input);
            //fflush(stdout);
        }
        while ((strlen(input)) >= MAX_INPUT_SIZE) { // flush it
            // reallocate the pointer
//          free(input);
//          char *input = malloc(2 * MAX_INPUT_SIZE);
//          if (input == NULL) {
//              fprintf(stderr, "Unable to malloc() in run_shell()!!\n\n");
//              exit(1);
//          }
            input = fgets(buffer, MAX_INPUT_SIZE + 1, inbuffer);
            // reset input
            fflush(inbuffer);
        }
        // flush it one more time
        input = fgets(buffer, MAX_INPUT_SIZE + 1, inbuffer);
        *jobnum += 1; // inc the job counter
        return (NORMAL);

    }

    if (input == NULL)  { // EOF or Ctrl-D
        retval = EXITVAL;
    }
    else
        if (!interactive) {
            printf("%s", input);
            //fflush(stdout); // add this back if i turn buffering back on
        }

    char *token = strtok(input, " \n\t");
    if (token == NULL) {// just ignore an all whitespace string
        return retval;
    }

    // ignore a single &
    if ((!retval) && !(strcmp(token, backgroundcmd) == 0)){
        command = token;
        args[arg_counter++] = token; // first arg should be program
        // check for the wait command
        while((token != NULL) && (retval < 1) && (retval != WAITERROR)) { // we don't want a jid retval
            lastarg = token;
            args[arg_counter++] = token = strtok(NULL, " \n\t");
        }
        if (lastarg[strlen(lastarg) - 1] == '&') {
            background = 1;
            if (strcmp(lastarg, backgroundcmd) == 0)
                // remove the last arg, it's a single &
                args[--arg_counter] = NULL;
            else {
                // erase the last character
                args[arg_counter - 2] = strtok(lastarg, "&");
            }
        }
        // check to see if we had a shell command
        if (strcmp(command, waitcmd) == 0) {
            // check to see if we had right number of args
            if (arg_counter != 3)
                retval = WAITERROR;
            else {
                retval = atoi(args[arg_counter - 2]);
                // check for 0 retval, it's bad
                if (retval == 0)
                    retval = WAITERROR; // treat it as a bad arg, no jid of 0
            }
        }
        if(strcmp(command, exitcmd) == 0) {
            retval = EXITVAL;
        }
        if(strcmp(command, jobcmd) == 0)
            retval = JOBVAL;
        // create a job
        if (retval == 0) {
            create_job(*jobnum, 0, command, --arg_counter, args,
                             background, job);
            *jobnum += 1;

            //// DO THE JOB!!
            job->pid = fork();
            if (job->pid == -1) {
                fprintf(stderr, "UNABLE TO FORK!! DYING!!\n");
                exit(1);
            }

            if (job->pid > 1) { // we are the parent...deal with stuff
                if (!job->background) { // just wait for it to die
                    waitpid(job->pid, &status, 0);
                }
            } else { // we are the child!!
                if ((execv(job->command, job->args)) < 0) {
                    fprintf(stderr, "Unable to exececute your command\n");
                    retval = CHILDEXIT; // 1 makes it exit...

                }
            }
        }
    }

    return retval;
}