hau1551.tar

main.cpp0000664000175000017500000000040512226066020011443 0ustar  daviddavid/*
*   Author: David Chau
*   File: main.cpp
*   Description: Driver main file.
*   This program is a shell program made for unix/linux systems
*/

#include "shell.h"

int main(int argc, char *argv[])
{
    shell myShell;
    myShell.runShell();
    return 0;
}shell.h0000664000175000017500000000163412226065575011316 0ustar  daviddavid/*
*   Author: David Chau
*   File: shell.h
*   Description: Header file to support implementation
*/

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>

#include "enums.h"

class shell
{
public:
    //Default constructor
    shell();

    //Runs the shell program
    void runShell();

protected:

    //Parses input into the first argument and additional arguments
    //Sees if there are any pipes, indirection, or redirection
    //Returns number of arguments if needed
    int parse(char *inputString, char *cmdArgv[], char **supplementPtr);
    
    //Goes to the end of the word and delimits it with a null character
    void nullDelimateArgs(char *srcPtr);

    //Function which executes OS calls
    void execute(char **cmdArgv, char **supplementPtr);

private:
    modes mode;
    char CWD[MAX_PATH];
    char *userInput;
    size_t len;
};shell.cpp0000664000175000017500000001201112226066243011631 0ustar  daviddavid/*
*   Author: David Chau
*   File: shell.cpp
*   Description: Shell implementation file for unix/linux OS's
*/

#include "shell.h"
shell::shell()
{
	mode = NORMAL;
	userInput = (char*)malloc(sizeof(char)*MAX_INPUT);
	len = MAX_INPUT;
}

void shell::runShell()
{
	char *supplement;
	char *cmdArgv[MAX_INPUT];

	while(true)
	{
		mode = NORMAL;
		getcwd(CWD, MAX_PATH);
		std::cout<< CWD << ">$ ";
		getline(&userInput, &len, stdin);

		//Seeing if the user entered exit. If they did, then exit normally
		if(strcmp(userInput, "exit\n") == 0)
			exit(1);

		parse(userInput, cmdArgv, &supplement);

		if(strcmp(*cmdArgv, "cd") == 0)
		{
			if(cmdArgv[1] == NULL)
				chdir(getenv("HOME"));
			else
				chdir(cmdArgv[1]);
		}
		else 
			execute(cmdArgv, &supplement);
	}
}

int shell::parse(char *inputString, char *cmdArgv[], char **supplementPtr)
{
	int cmdArgc = 0;
	bool stopParsing = false;
	char *inputCharPtr = inputString;
	//Going through the entire input line
	while(*inputCharPtr != '\0' && stopParsing == false)
	{
		*cmdArgv = inputCharPtr;
		cmdArgc++;

		//Iterating though all alpha-numeric characters
		while((isspace(*inputCharPtr) == 0) && *inputCharPtr != '\0' 
				&& stopParsing == false)
		{
			switch(*inputCharPtr)
			{
				case '&':
					mode = BACKGROUND;
					break;
				case '>':
				case '<':
					if(*inputCharPtr == '>')
						mode = OUTPUT_REDIRECTION;
					else
						mode = INPUT_REDIRECTION;

					*cmdArgv = '\0';
					inputCharPtr++;

					//Iterating the input until the next argument
					while(*inputCharPtr == ' ' || *inputCharPtr == '\t')
						inputCharPtr++;
					*supplementPtr = inputCharPtr;
					nullDelimateArgs(*supplementPtr);
					stopParsing = true;
					break;
				case '|':
					mode = PIPELINE;
					*cmdArgv = '\0';
					inputCharPtr++;

					//Iterating the input until the next argument
					while(*inputCharPtr == ' ' || *inputCharPtr == '\t')
						inputCharPtr++;
					*supplementPtr = inputCharPtr;
					stopParsing = true;
					break;
				default:
					//This should have nothing in it because we don't need
					//to do anything while scanning the input.
					break;
			}
			inputCharPtr++;
		}
		//Going to the next space and replacing all non-alpha characters
		//with a null character
		while((isspace(*inputCharPtr) != 0) && stopParsing == false)
		{
			*inputCharPtr = '\0';
			inputCharPtr++;
		}
		cmdArgv++;
	}
	*cmdArgv = '\0';
	return cmdArgc;
}

void shell::nullDelimateArgs(char *inputCharPtr)
{
	//Going to the end of the word
	while(*inputCharPtr != ' ' && *inputCharPtr != '\t' && *inputCharPtr != '\n')
		inputCharPtr++;

	//Making the last argument be a null character
	*inputCharPtr = '\0';
}

void shell::execute(char **cmdArgv, char **addArgsPtr)
{
    //Making two process ids
    pid_t pid, pid2;
    FILE *fp;
    int status;

    //Creating pipes so that threads can share info through IPC's
    int fd[2];
    char *cmdArgv2[MAX_INPUT];
    char *addArgs2 = NULL;
    
    if(mode == PIPELINE)
    {
        if(pipe(fd))                    //create pipe
        {
            std::cerr<< "An error occured making a Pipe failed!";
            exit(-1);
        }
        parse(*addArgsPtr, cmdArgv2, &addArgs2);
    }

    pid = fork();
    if( pid < 0)
    {
        std::cerr<< "An error occured creating a child process.\n";
        exit(-1);
    }
    //Child process
    else if(pid == 0)
    {
        switch(mode)
        {
            case OUTPUT_REDIRECTION:
                //Opens the file and gives write/update privileges
                fp = fopen(*addArgsPtr, "w+");
                dup2(fileno(fp), 1);
                break;
            case INPUT_REDIRECTION:
                //Opens the file and gives read access
                fp = fopen(*addArgsPtr, "r");
                dup2(fileno(fp), 0);
                break;
            case PIPELINE:
                //close input of pipe
                close(fd[0]);
                //Sending data to another process
                dup2(fd[1], fileno(stdout));
                close(fd[1]);
                break;
        }
        if(execvp(*cmdArgv, cmdArgv) == -1)
            std::cout<<"The command is not supported\n";
    }
    //Parent process
    else
    {
        if(mode == BACKGROUND)
            ;
        else if(mode == PIPELINE)
        {
            //wait for child process 1 to finish
            waitpid(pid, &status, 0);
            pid2 = fork();
            if(pid2 < 0)
            {
                std::cerr<< "There was an error forking the second process.\n";
                exit(-1);
            }
            else if(pid2 == 0)
            {
                //close output to pipe
                close(fd[1]);
                //Reading input from other process
                dup2(fd[0], fileno(stdin));
                close(fd[0]);
                if(execvp(*cmdArgv2, cmdArgv2) == -1)
                    std::cout<<"The command is not supported\n";
            }
            else
            {
                close(fd[0]);
                close(fd[1]);
            }
        }
        else
            waitpid(pid, &status, 0);
    }
}enums.h0000664000175000017500000000064012226065406011323 0ustar  daviddavid/*
*   Author: David Chau
*   File: enums.h
*   Description: File that contains structures and definitions
*/

//Max history path of user's location
#define MAX_PATH    100
//Max number of characters that can be entered by the user
#define MAX_INPUT   80

//Different Modes which can occur
//Dependent on user input command
enum modes
{
    NORMAL, OUTPUT_REDIRECTION, INPUT_REDIRECTION, 
    PIPELINE, BACKGROUND
};makefile0000664000175000017500000000026112226026723011521 0ustar  daviddavidmyShell: main.o shell.o
	g++ main.o shell.o -o myShell
main.o: main.cpp shell.h
	g++ -c main.cpp
shell.o: shell.cpp shell.h enums.h
	g++ -c shell.cpp
clean:
	rm -rf *o shellLab
readme.txt0000664000175000017500000000217212226074424012023 0ustar  daviddavidDavid Chau
10/11/2013
CSCI 3453 Operating Systems
Lab-1

README
	The command line interpreter, called a shell, is an application program
	that gets commands from a keyboard and uses the system call interfaces
	to invoke OS functions.

IMPLEMENTATION DETAILS
	Programming language:  C++
	
	This program was developed using Vmware ubuntu 12.04 and
	csegrid.ucdenver.pvt.The main computing environment is a Windows 7 
	64-bit machine.

SHELL SUPPORT
	(1) exit or stop shell commands
	(2) Commands with no arguments
	(3) Commands with arguments
	(4) Commands with without arguments, whose output is redirected to a file
	(4) Commands, with or without arguments, whose input is redirected from a
		file
	(f) Display error messages if the typed command has errors or can’t be
		found

FILES
	(1) main.cpp
	(2) shell.cpp
	(3) shell.h
	(4) enums.h
	(5) makefile
	(6) readme.txt

TO RUN
	(1) Untar the hau1551.tar file by typing the following at the 
	command prompt:

		tar xvf hau1551.tar

	(2) Run the make command

		make makefile

	(3) Execute the program

		./myShell

	(4) Exit the shell

		exit