msh.c

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include "proto.h"

/* Constants */

#define LINELEN 1024
#define EXPANDEDLEN 200000

/* Globals */

volatile sig_atomic_t sig_int = 0;
int last_exit_status = 0;
int m_argc;
int m_shifted_argc;
char **m_argv;
char **m_shifted_argv;
pid_t  cpid = 1;

/* Prototypes */

void processline (char *line, int inFD, int outFD, plFlags FLAGS);
int findUnquotChar(char *line, char);
void print_args(char **args);
void print_fd(int fd);

/* SIG HANDLERS */

void sigint_handler(int sig)
{
    sig_int = 1;
    if(!cpid) kill (0, SIGINT);
}

/* Shell main */

int main (int mainargc, char **mainargv)
{
    /* PROTOTYPES IN MAIN */
    void sigint_handler(int sig);

    /* Defining Locals */
    struct sigaction sa;
    plFlags pl_flags = {1U, 1U, 1U};
    char *promptStr = "%% ";
    char   buffer [LINELEN];
    int    len;
    FILE *fp;

    cpid = getpid();

    sa.sa_handler = sigint_handler;
    //sa.sa_flags = 0;
    sa.sa_flags = SA_RESTART;
    sigemptyset(&sa.sa_mask);

    if(sigaction(SIGINT, &sa, NULL) == -1)
    {
        perror("sigaction");
        exit(1);
    }

    m_argc = mainargc;
    m_shifted_argc = mainargc;
    m_argv = mainargv;
    m_shifted_argv = mainargv;

    if(m_argc > 1) fp = fopen(m_argv[1], "r");
    else fp = stdin;

    if(fp == NULL)
    {
        fprintf(stderr, "./msh: Can not open file %s\n", m_argv[1]);
        exit(127);
    }

    while(1)
    {
        if(fp == stdin)
        {
            if(!(promptStr = getenv("P1"))) fprintf(stderr, "%% ");
            else fprintf(stderr, "%s", promptStr);
        }

        if(fgets(buffer, LINELEN, fp) != buffer) break;

        len = strlen(buffer);
        if (buffer[len-1] == '\n') buffer[len-1] = 0;

        processline (buffer, 0, 1, pl_flags); //, mainargc, mainargv, shiftedMArgV);
    }

    if (!feof(fp)) perror ("read");
    if(fclose(fp) != 0) perror("close");
    return 0;       /* Also known as exit (0); */
}


void processline (char *line, int inFD, int outFD, plFlags FLAGS) //, int mainargc, char **mainargv, char **shiftedMArgV)
{
    int wait_result;
    int    status;
    char expanded_line[EXPANDEDLEN];
    char **args;
    char *line_itr = line;
    int command_count;

    int pix;
    int fd[2];
    int saveFD;

    int line_len = strlen(line);
    plFlags pl_flags = {0U, 0U, 0U};

    if(FLAGS.EXPAND)
    {
        if(expand(line, expanded_line, EXPANDEDLEN)) return; //, mainargc, mainargv, shiftedMArgV)) return;
        line_itr = expanded_line;
        line_len = strlen(expanded_line);
    }

    if((pix = findUnquotChar(line_itr, '|')))
    {
        line_itr[pix] = 0;

        if(pipe (fd) < 0) perror("pipe");
        processline(line_itr, inFD, fd[1], pl_flags);
        close(fd[1]);
        saveFD = fd[0];
        line_itr = &(line_itr[pix+1]);

//print_fd(saveFD);

        while((pix = findUnquotChar(line_itr, '|')) && pix < line_len)
        {
            line_itr[pix] = 0;

            if(pipe (fd) < 0) perror("pipe");
            processline(line_itr, saveFD, fd[1], pl_flags);
            close(fd[1]);
            close(saveFD);
            saveFD = fd[0];
            line_itr = &(line_itr[pix+1]);

//print_fd(saveFD);
        }

        pl_flags.WAIT = FLAGS.WAIT;
        processline(line_itr, saveFD, outFD, pl_flags);
        close(saveFD);

        return;
    }

    command_count = arg_parse(expanded_line, &args);
    /* print_args(args); */

    if(!command_count) return;

    if(!exec_if_built_in(args, outFD))
    {
        /* Start a new process to do the job. */
        cpid = fork();
        if (cpid < 0) {
            perror ("fork");
            free(args);
            return;
        }

        /* Check for who we are! */
        if (cpid == 0) {
          /* We are the child! */

            /* Turning stdout into pipe output if needed */
            /*if((dup2(outFD, 1)) < 0)
            {
                perror("dup");
                return;
            }*/

            /* THIS IS PROBABLY WRONG!!!!!! */
                if(inFD != 0)
                {
                    if((dup2(inFD, 0)) < 0)
                    {
                        perror("dup");
                        return;
                    }
                }

                if(outFD != 1)
                {
                    if((dup2(outFD, 1)) < 0)
                    {
                        perror("dup");
                        return;
                    }
                }



            execvp(args[0], args);
            perror ("exec");
            exit (127);
            last_exit_status = 127;
        }

        /* Have the parent wait for child to complete */
        if(FLAGS.WAIT)
        {
            if(wait(&status) < 0) perror("wait");
            last_exit_status = ((WEXITSTATUS(status) || !WIFEXITED(status)) ? 127 : 0);
        }
    }

    free(args);
}


/* Function that returns a pointer to the
first instance of ch in line */
int findUnquotChar(char *line, char ch)
{
    int i = 0;
    int inQuoteFlag = 0;

    while(line[i])
    {
        if(line[i] == ch && !inQuoteFlag) return i;
        else if(line[i] == '"') inQuoteFlag = !inQuoteFlag;
        i++;
    }
    return 0;
}


/* Procedure for testing purposes,
prints the arguments of a command array */
void print_args(char **args)
{
    int i = 0;
    char** cmd = args;

    printf("COMMANDS: ");
    while(cmd[i] != 0)
    {
        printf("'%s'\n", cmd[i]);
        i++;
    }
}

void print_fd(int fd)
{
    int bytes_read;
    int total_bytes_read = 0;
    int bufsize = 256;
    char buf[bufsize];

    while((bytes_read = read(fd,buf,bufsize-1)))
    {
        if(bytes_read < 0)
        {
            if(errno == EWOULDBLOCK || errno == EAGAIN) continue;
            else if(errno == EINTR) fprintf(stderr, "WE GOT AN EINTR SIGNAL\n");
            else
            {
                perror("read");
                break; // Or should this be exit?
            }
        }
        else if(bytes_read > 0) total_bytes_read += bytes_read;
    }
    buf[total_bytes_read] = 0;
    fprintf(stderr, "Contents of FD: %s\n", buf);
}