Introduction

In this assignment you will be writing more complicated wrapper programs around external programs.

Due: One week

Deliverables: Commit and push to Github. Submit to Gradescope.

Assignment Details

There are two parts to this assignment.

Background

In this assignment, you will learn how the shell executes various commands. As part of this, we'll learn some new commands to test our implementation.

The echo command prints each item in the argument list.

The sort command allows you to sort a csv file by columns. For example, the following command sorts the file by using comma $(,)$ as the token to separate columns, and sort using the first column, and using numerical sort.

$ $/$usr$/$bin$/$sort $-$t$,-$k$1-$n tests$/$cities$.$csv

The cut command cuts a CSV file using the comma $(,)$ and extract the first column $($yeah$,$ the two commands use t and d$,$ k and f for the same things $)$

$ $/$usr$/$bin$/$cut $-$d$,-$f$1$ tests$/$cities$.$csv

The head command extract the first N lines. So this example prints the first $4$ lines.

$ $/$usr$/$bin$/$head $-$n$4$ tests$/$cities$.$csv

The tail command is the opposite. This one gets the last $1$ line.

$ $/$usr$/$bin$/$tail $-$n$1$ tests$/$cities$.$csv

Part A

For this part, you will write a simple command$-$line interface. The program will accept several command line arguments. The first argument will be the command to run, and the remainder will be the arguments to the command. For example:

$./$build$/$src$/$parta$\_$main $/$usr$/$bin$/$echo

will run the echo command without any arguments using our program, whereas

$./$build$/$src$/$parta$\_$main $/$usr$/$bin$/$echo hello boston ma usa

will run the echo command with four arguments.

To run the tests for this part, run:

$./$run$.$sh testa

Part B

For this part, you will extend the program from Part A$.$ The program has two modes. In the first mode, it will run the same as Part A$.$

The second mode contains a colon character in part of the arguments. This character will split the arguments into two parts. The first part will run the first command, and the second part will run another command. The two commands will be connected via pipe. For example:

$$./$build$/$src$/$partb$\_$main $/$usr$/$bin$/$head $-$n$4$ tests$/$cvs$1.$csv : $/$usr$/$bin$/$tail $-$n$1$

It's equivalent to the command:

$ $/$usr$/$bin$/$head $-$n$4$ tests$/$cvs$1.$csv $|/$usr$/$bin$/$tail $-$n$1$

Notice we're replacing the pipe character with the colon character. This pair of commands will first extract the top $4$ lines from the given file, and then extract the last line from that. In other words, it will print the $4$th line.

For this to work, there are a number of steps you need to make. First, you need to check if you're running in mode $1$ or mode $2.$ This can be determined by checking if $"$:$"$ exists in as an argument. If it doesn't exist, you're in mode $1,$ and you can reuse the code from Part A$.$

If not, you're in mode $2.$ Create a pipe and then fork a child process. The parent process will be the writer, so it should close its read end. It should also redirect STDOUT to the write end of the pipe:

close$($read$\_$fd$)$;

dup$2($write$\_$fd$,$ STDOUT$\_$FILENO$)$;

exec$(...)$;

The child process will be the reader. It should close its write end of the pipe and convert the pipe's read end into the standard input:

close$($write$\_$fd$)$;

dup$2($read$\_$fd$,$ STDIN$\_$FILENO$)$;

exec$(...)$;

Helper Functions

To help you on the assignment, there are helper functions in src$/$partb$.$c$,$ and some unit tests in tests$/$test$\_$b$.$cpp$.$

The first helper function is the split$\_$args function. This function takes in $4$ arguments, the argc, and the argv of the program itself. It also accepts $2$ other arguments, args$1$ and args$2.$ These are pointers to malloc'd arrays of strings $($char pointers$).$ You task is to skip the first argument $($argv$[0])$ and look for the colon $("$:$").$ Everything before the colon is copied to args$1,$ and everything after to args$2.$ For example, if you run:

split$\_$args$(2,\{$ "partb", "echo" $\},$ args$1,$ args$2)$;

args$1$ will contain a string array that contains "echo" and NULL, and args$2$ will contain NULL.

On the other hand if you run:

split$\_$args$(4,\{$ "partb", "echo", $"$:$",$ "sort" $\},$ args$1,$ args$2)$;

args$1$ will contain a string array that contains "echo" and NULL, and args$2$ will contain "sort" and NULL.

The second helper function run$\_$pipe takes in $2$ pairs of arguments. Each pair contains the command to run and the arguments, which are then passed to the exec system call. In this function, create the pipe, child process, and rewire the STDIN$/$STDOUT and exec.

To run the tests for this part, run:

$./$run$.$sh testb