heres my version of the shell which handles multiple piping, in_redirects, and out_redirects

thanks again sarah!

main:

//import header file
#include “system_call.h”

using namespace std;

int main() {

//initialize three char array: one for original commands, and the next
//two if if a pipe function is used with first containing the commands
//in the correct order and the next contianing exactly which pipe type(|, )
char *cmds[MAX_ARGS], *ordered_cmds[MAX_ARGS], *cmd_types[MAX_ARGS];;

//initialize enum pipe_redirect defined in the header file
PipeRedirect pipe_redirect;

//while “C++_Shell” prompt
while (true) {

cout < “;
//immediately call parse_command function and return whther any pipes will be needed
pipe_redirect = parse_command(cmds);
//if pipes needed, call cmds_prep funtion to prepare two arrays for run_pipelines function
if (pipe_redirect == PIPE_REDIRECT)
cmds_prep(cmds, ordered_cmds, cmd_types);
//else execute commands with no pipes
else
exec_cmd(cmds);

//clear all respective arrays
for (int i=0; i<MAX_ARGS; i++)
{
ordered_cmds[i] = NULL;
cmds[i] = NULL;
cmd_types[i] = NULL;
}

}

//let OS know evrything is
return 0;
}

header file:

//include all librarys needed for system calls, string functions, and stream
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//initialize enum piperedirect which can be either PIPE_REDIRECT indicating piping will be used
//or NEITHER
enum PipeRedirect {PIPE_REDIRECT, NEITHER};

//initialize constant integer at 256 to be used for most array limits and in most loops
const int MAX_ARGS = 256;

//initialize amp_flag and set to false
static bool amp_flag = false;

//this function reads in user commands ‘live’ and checks if user wants to quit
//if not, takes user input and converts it to char array compatible format(c-string)
//and prepares original commands array. Finally, checks if any types of pipe commands were entered
// and returns enum piperedirect as such
PipeRedirect parse_command(char**);

//executes commands without pipes and is instructed to wait if the amp_flag is still false
void exec_cmd(char**);

//prepares commands for run_pipelines function which requires the commands be in a set order
//depending on which specific pipe command is used. Also sets seperate array with pipe types
//and prepares integer for number of times run_piplines loop must iterate
void cmds_prep(char**, char**, char**);

//most complex function. Iterates through a loop and executes command depending on pipe
//type accordingly. Also handles pipe maintnenance(two pipes used) through each iteration
//accordingly by closing and duplicating relevant pipes
void run_pipelines(int, char**, char**);

//simple bool function which checks if the user entered the words ‘quit’ or ‘exit’
bool check_quit(string);

bool checkfor_amp(string);

class which handles everything:
#include “system_call.h”

PipeRedirect parse_command(char** cmds) {

// Assume no pipe or redirect will be found.
PipeRedirect result = NEITHER;

//initiate character used as the ‘c-string’
char *cstr;

//initiate string which will be read in as user arguments
string str_cmd;

//initiate integer to count number of arguments
int num_of_args = 0;

//while user is entering input
while(cin >> str_cmd)
{

//check if user wants to quit
if (check_quit(str_cmd))
{
//if true, print message and exit
cout << "Till next time\n";
exit(0);
}

//check for ampersand
if (checkfor_amp(str_cmd))
{
amp_flag = true;
break;
}

//define size of 'c-string', copy original argument into 'c-string',
//and put 'c-string' into current location in array
cstr = new char[str_cmd.size()+1];
strcpy(cstr, str_cmd.c_str());
cmds[num_of_args] = cstr;

num_of_args++;

//if user hits return
if (cin.get() == '\n')
break;

}

//loop through arguments and check for any typr of pipe command
for (int i=0; i”) == 0 || strcmp(cmds[i], “<") == 0)
{
// Pipe found!
result = PIPE_REDIRECT;
break;
}

}

//make last element in array NULL for execvp call
cmds[num_of_args] = NULL;

//return piperedirect
return result;
}

void exec_cmd(char** cmds)
{

//initiate integer for pid
pid_t pid;

//fork process
pid = fork();

//check for error in pid returned
if (pid < 0)
perror("Error (pid < 0)");

// child process
else if (pid == 0)
{

//execute command and return error if execvp fails
execvp(cmds[0], cmds);
perror("execvp error");

}

// parent process
else if(!amp_flag)
// only wait if no ampersand
waitpid(pid, NULL, 0);

}

void cmds_prep(char** cmds,char** ordered_cmds,char** cmd_types)
{
//initiate two integers, first for index(type_count) in cmd_types array, and second for number of commands
int type_count = -1, num_cmds = 0;

//initiate character which will be all user arguments(including pipe arguments) concatenated
char *cmds_cat_final;

//initiate string which will be used to concatenate arguments
string cmds_cat = "";

//loop through arguments and concatenate
for(int i = 0; i < MAX_ARGS;i++)
{
if(cmds[i] != NULL)
{
cmds_cat += cmds[i];
cmds_cat += " ";
}

//hit NULL so break out of loop
else
break;

}

//define size of final concatenated string, copy original string into final concatenated char,
//and put result into first location in orginal commands array since this array will no longer
//be used
cmds_cat_final = new char[cmds_cat.size()+1];
strcpy(cmds_cat_final, cmds_cat.c_str());
cmds[0] = cmds_cat_final;

//loop through commands array to fill pipe type array
for(int i = 0; i < MAX_ARGS; i++)
{
//done, so break
if(cmds[i] == NULL)
break;

//found pipe command
else if (strcmp(cmds[i], "”) == 0)
cmd_types[++type_count] = cmds [i];

}

//loop through pipe types array and order commands in the ordered_commands array accordingly
//as well as count number of ordered_cmds elements
for(int i = 0; i “) == 0)
{
//seperate preceding section from pipe-type syntax and put in array
ordered_cmds[i] = strsep(&cmds[0], cmd_types[i]);
num_cmds++;
}

//found an in_redirect which is a little more tricky since the order of
//arguments before and after the “<" command need to be reversed so that
//the name of the text file is put first so that the file contents can be
//written to the pipe in the run_pipelines function
else if (strcmp(cmd_types[i], "<") == 0)
{
//put section of arguments before the redirect command in the next
//element of the ordered_cmds array
ordered_cmds[i + 1] = strsep(&cmds[0], cmd_types[i]);
num_cmds++;

//if there is another pipe-type command, then seperate the section
//after the "<" command and put it in the current element of the
//ordered_cmds array
if(cmd_types[i + 1] != NULL)
{
ordered_cmds[i] = strsep(&cmds[0], cmd_types[i + 1]);
num_cmds++;
}

//else just put the rest of the arguments in current section
//since all other arguments have already been seperated and taken out
else
{
ordered_cmds[i] = cmds[0];
cmds[0] = NULL;
}

//since handled two sections of commands, increment i
i++;
}
}

//call run_pipelines with the number of command sections,
//prepared array of arguments in correct order, and array of pipe-types
run_pipelines(num_cmds, ordered_cmds, cmd_types);

}

void run_pipelines(int num_cmds, char** ordered_cmds,char** cmd_types)
{
//initiate two chars, one used to read and write from a file, and another to hold
//a single argument seperated by " " temporarely
char buffer, *temp_cmd;

//initiate two integer arrays, one for the old pipe, and one for the new pipe
//and intiate two integers, one for the file reader, and one to count characters
//written or ead
int old_fds[2], new_fds[2], file, char_count;

//initiate integer for pid
pid_t pid;

//loop through argument sections seperately and each time fork of
//a child process to execute relative command section
for(int i = 0; i 0)
temp_cmds[++cmd_count] = temp_cmd;

}

} while(strlen(ordered_cmds[i]) > 0);

//prepare last element as NULL for execvp function
temp_cmds[++cmd_count] = NULL;

//if there is a next commands section, make new pipe
if( i 0)
{
close(old_fds[1]);
dup2(old_fds[0], 0);
close(old_fds[0]);

}

//if their is a next commands section, close new pipe and
//duplicate write part of new pipe
if( i < num_cmds – 1)
{
close(new_fds[0]);
dup2(new_fds[1], 1);
close(new_fds[1]);
}

//if this is first time in loop
if(i == 0)
{
//if pipe-type is in_redirect, open file and write to new pipe
if(strcmp(cmd_types[i], " 0)
write(1, &buffer, 1);
}

//else if pipe-type was not in_redirect, then simply execute commands section
else
execvp(temp_cmds[0], temp_cmds);
}

//not first time in loop
else
{
//if pipe-type was “|”, then execute commands section
if(strcmp(cmd_types[i - 1], “|”) == 0 || strcmp(cmd_types[i - 1], “”) == 0)
{
file = open(temp_cmds[0], O_WRONLY | O_CREAT, 0666);

//while reading from pipe and end of pipe not reached, write to file
while((char_count = read(0, &buffer, 1)) > 0)
write(file, &buffer, 1);
}
}

exit(0);
}

//parent process
else
{
//if there was a prevoius commands section, close old pipe
if(i > 0)
{
close(old_fds[0]);
close(old_fds[1]);
}

//if there is a next commands section, then set old pipe to new pipe
if( i < num_cmds – 1)
{
old_fds[0] = new_fds[0];
old_fds[1] = new_fds[1];
}

//if in last loop iteration, then wait for process id
if(i == num_cmds – 1)
waitpid(pid, NULL, 0);
}
}

}

bool check_quit(string str_cmd)
{

for(int i = 0; i < str_cmd.length(); i++)
str_cmd[i] = tolower(str_cmd[i]);

if(str_cmd == "quit" || str_cmd == "exit")
return true;
else
return false;
}

bool checkfor_amp(string str_cmd)
{

for(int i = 0; i < str_cmd.length(); i++)
if(str_cmd[i] == '&')
{
return true;
}

return false;
}

Anna

Thanks for posting your code, it was quite helpful in figuring out what my shell was doing wrong (piping is the bane of my existence…)

Just a note: the reason you have the infinite prompt loop in “redirect_cmd” is because the child process is an *exact* copy of the parent process, including the program counter, the execution stack and your “main”. So the child was continuing on past the end of the if block, forking another child process, returning to main, printing a prompt, and so on. The reason the call to “exec” fixed it is process overlaying, where the execution code of the process is replaced with the execution code of the exec’d function. Thus, because “echo” calls exit, your process obeyed and exited.

A better solution would be to simply call exit(0) there instead of exec.

void pipe_cmd(char** cmd1, char** cmd2){
           int fds[2];
           pipe(fds);
	   pid_t pid1, pid2;

           // child process #1
           if (pid1 = fork() == 0) {
                dup2(fds[1], 1);
		close(fds[0]);
		close(fds[1]);
                execvp(cmd1[0], cmd1);
                perror("execvp failed");

                // child process #2
                } else if ((pid2 = fork()) == 0) {
                  dup2(fds[0], 0);

                  close(fds[1]);
                  execvp(cmd2[0], cmd2);
                  perror("execvp failed");

            } else {
    	close(fds[1]);

    	waitpid(pid1, NULL, 0);
	waitpid(pid2, NULL, 0);

		}
}

I plan to take an OS course at some point (CS degree ftw) and I’ll bookmark this for then :P

I really like the “SarahShell>” haha :)

This will undoubtedly be useful to many. A common program which runs under both windows and unix will also be of much value. :)