Description
Assignment 3: (10%): Processes and
pipes
Introduction
In this assignment, you will be writing your own mini-shell. The shell should be able to launch
commands in new processes, as well as support the built-in commands cd and exit. Your shell will
also support standard input, output and error redirection, as well as the pipe (|) operator to chain
commands. You will be provided with starter code to help you get started with the implementation.
Follow the instructions in the handout below carefully, so that you implement your code correctly and
we receive all the right files.
Please read over this entire handout at least twice before you get started, so that you have a clear
picture of what you have to do.
Your first step should be to check out your repository, as in the previous assignments, and make
sure that you can commit to it.
You must do your assignment on one of the CDF lab machines or remotely through SSH
at cdf.toronto.edu, so please make sure your code works on CDF machines! (It is highly
likely that parts of this code will not work on Windows, and possibly not on OSX.)
Objective
In this assignment, your task is to implement a basic shell that allows the execution of command line
tools and programs. Early in the course, we worked with the Unix shell, and more recently we have
studied Unix processes and pipes. It is time to put all of this together and write your own mini-shell
that can almost give bash a run for its money.
Your shell should allow running command line programs that have zero, one or multiple arguments.
As we have seen in the lectures, commands can be built-in functions where no process is spawned,
simple non-builtin commands where a process is spawned to execute them, and complex nonbuiltin commands where an operator such as a pipe (|) is used to chain commands. You should
build this functionality into your shell one at a time using the steps recommended below:
Step 1: read through all of the starter code, especially the comments. You will not be able to
make progress until you understand the basic structures and the control flow.
Step 2: built-in commands (i.e. cd and exit)
Step 3: simple commands with no redirection
Step 4: simple commands with redirection
Step 5: complex commands (i.e. those that involve the pipe operator)
Starter code
The starter code will be committed to your repository in the a3 directory. You should not have to
modify anything except shell.c, in the places indicated with “TODO” comments.
The starter code provided will guide you step by step in solving this assignment.
The parser.c and parser.h files deal with parsing commands and storing them in data structures
(see below). The shell.c and shell.h files contain functions that process commands and execute
them accordingly. You should read the code and understand it, then proceed to fill in all
the TODO spots left for you to implement.
Built-in commands
The only built-in commands you need to support are exit and cd.
The exit command should exit the current shell session, and the cd command is used to change
the current working directory.
The cd command can accept both relative and absolute (i.e. relative to root) paths. (See the
comments in the code for hints on how to implement this.) For example:
cd csc209/assignments
cd /home/bogdan/csc209/assignments/
cd ../john/csc209/assignments/
cd ../../home/jane/csc209/assignments/
Note: you do NOT have to support anything involving expanding environment variables or special
symbols such as $HOME, ~, or *.
Simple and complex commands
Your next task is to implement simple commands and then complex commands. Before you can get
started on these tasks, you need to understand the basic structures used to implement commands.
Your shell should allow both simple commands, and complex commands that can contain any
number of simple commands chained using special operators. The only special operator you will
implement for this assignment is the pipe (|) operator. (Other operators are described at the end of
this document in the Optional section.)
Your shell should also support the following redirection operators:
Redirection of standard input from a file: <
Redirection of standard output to a file: >
Redirection of standard error to a file: 2>
Redirection of both standard output and standard error to a file: &>
Note: you do NOT have to support redirection in append-mode (>> and 2>>).
Basic Structures
Simple commands are stored in the following structure:
typedef struct simple_command_t {
char *in, *out, *err; /* Files for redirection, optional */
char **tokens; /* Program and its parameters */
int builtin; /* Builtin commands, e.g., cd */
} simple_command;
This is used for simple commands, involving a single program and no pipe chaining. A simple
command can use redirection: in, out and err are strings containing the names of the files where
the corresponding redirection should occur (stdin should be redirected to the file whose name is
stored in in, stdout redirected to the file whose name is stored inout, etc.).
The builtin flag indicates whether the command is builtin or non-builtin. Valid values for
the builtin flag are: 0 (non-builtin), 1 for cd, and 2 for exit. You should use the predefined
macros BUILTIN_CD and BUILTIN_EXIT instead of hardcoding the values 1 and 2. This way your
code can benefit from more clarity and extensibility.
The tokens member is an array of strings (array of pointers to characters) where each element of
the array is a word in the command. The last element of the array is NULL.
For example, ls -l will be split into 2 tokens ls and -l, followed by a NULL pointer.
Hint: the NULL pointer simplifies your task when using certain exec calls.
Remember that complex commands are simple commands chained together with the pipe (|)
operator. The pipe operator allows chaining of commands, by sending the output of the first
command as input to the second command. You have already seen a few examples of this in the
lectures.
Complex commands are defined in the following structure command:
typedef struct command_t {
/* Two commands chained using a special operator. In turn, each one can
* contain multiple commands itself; */
struct command_t *cmd1, *cmd2;
/* Simple command, no pipe */
simple_command* scmd;
/* In this assignment, consider only “|”. */
char oper[2];
} command;
This is a general form of a command. A command can be simple (no special operators), in which
case scmd is non-NULL, or it can be complex in which case scmd will be NULL.
If it is a complex command, cmd1 and cmd2 are the two chained commands. In
turn, cmd1 and cmd2 might be complex commands themselves. In the starter code, you are given a
hint on how to deal with them by using recursion. The oper string is used to store the
special | operator for chaining cmd1 and cmd2.
In this assignment, you are NOT allowed to use the popen or system functions.
For file I/O, redirection, and processes, you are working at a low level using file descriptors.
Consequently, you should only use POSIX functions, like open and close. Functions such
as fopen or fclose are not to be used in this assignment.
Sample shell commands you should try (just a few
examples)
Here are some commands. Notice that the prompt includes the current working directory. The first
command, shell is typed at Bash to start our shell. The rest of the commands are run from our shell
(not Bash).
$ ./shell
/home/bogdan/csc209/a3/> pwd
/home/bogdan/csc209/a3/> ls -l
/home/bogdan/csc209/a3/> ls -l > file.out
/home/bogdan/csc209/a3/> cat file.out
/home/bogdan/csc209/a3/> ls -l | wc -l
/home/bogdan/csc209/a3/> ls -l | grep file1
/home/bogdan/csc209/a3/> ls -l > filelist.out | wc -l
/home/bogdan/csc209/a3/> cat filelist.out
/home/bogdan/csc209/a3/> ls -l | wc -l > wc.out
/home/bogdan/csc209/a3/> cat wc.out
/home/bogdan/csc209/a3/> ls -l > ls.out | wc -l > wc.out
/home/bogdan/csc209/a3/> cat ls.out
/home/bogdan/csc209/a3/> cat wc.out
/home/bogdan/csc209/a3/> rm -f ls.out wc.out
/home/bogdan/csc209/a3/> ls -l | grep bogdan | wc -l
/home/bogdan/csc209/a3/> ps aux | grep bogdan | grep bash | grep -v grep
| wc -l
/home/bogdan/csc209/a3/> ls -l | grepp bogdan (should say something like: “grepp:
No such file or directory”)
/home/bogdan/csc209/a3/> lsa -l | grep bogdan (similarly, regarding mistyped “lsa”)
Also, make sure to run several commands involving cd, as shown earlier in the handout.
Once you are done testing these and more, one cool thing you could try is to run your shell program
within your own shell. This way you can create a new shell session as a child process of your own
shell. Again, the first shell is being typed at Bash to start-up our shell, and then the rest is typed at
our shell (not Bash).
$ ./shell
/home/bogdan/csc209/a3> ./shell
/home/bogdan/csc209/a3> echo Woo-hoo, new shell within the shell
Woo-hoo, new shell within the shell
/home/bogdan/csc209/a3> exit
/home/bogdan/csc209/a3> echo I am back to the parent shell
I am back to the parent shell
/home/bogdan/csc209/a3> exit
$
After the second exit, you exit the parent shell as well, so you are back to your regular Bash shell.
Submission instructions
CODE THAT DOES NOT COMPILE WILL GET 0 MARKS! It’s better that you submit code with
partial functionality than code that does not compile at all.
To get full marks, your code must be well-documented. Please include comments wherever
appropriate, and indent your code properly.
Please do not submit executables or anything other than source files and header files. You may
choose to submit a README.txt file if you want to add additional information that may be useful to
the marker such as implementation decisions that you made or an indication of optional additions
you implemented. If you were not able to complete the assignment, the README.txt file should
include an explanation of the parts that you believe to be working or not working.
Please make sure that you have committed all your source files, the makefile and
your README.txt (if you have created one).
Submission checklist:
You can make your life a lot simpler by ensuring that your submission is complete. When you first sit
down to do some work on this assignment, check out the repository. Notice which files are already in
the repository. Every time you create a new file, run svn add immediately to ensure that future
commit operations will commit the new file as well.
Use version control as it was meant to be used. Commit your work frequently — at least once every
2-3 hours that you are working on the assignment. This will prevent any last minute svn problems,
and provide a record of your work.
Here is a list of things that you should do on CDF at least an hour before the assignment deadline:
Create a temporary directory in your account (not one that is a subdirectory of your working
directory for your repository).
Check out your repository into this empty directory to be sure that the correct files have been
committed.
Run make to be sure that the shell program compiles without warnings or error.
Run shell and try a few commands to make sure that it works as you expected.
Optional Features
None of the following are required for credit. These are optional features that you might have fun
implementing when you finish the required functionality described above.
Variables and Substitutions
Expanding environment variables (preceded by $), such as in paths to commands or files.
Defining new environment variables for the current shell session.
Wildcard substitution, e.g., ls *.txt
Double quotes, single quotes, and back quotes
More Operators
& operator sends a process to the background, as we’ve seen in lectures. However, it can be
used to run 2 commands in parallel as well. For example, the following commands will be run in
parallel:
ls & whoami
The ; operator allows running multiple commands in one run, sequentially, e.g.,
ls ; whoami ; pwd
The && operator is a logical AND operator that lets you execute a second command iff the first
command runs successfully (the exit status of the first command is zero), e.g.,
$ mkdir newfolder && cp file.txt newfolder
(If the mkdir is successful, copy a file into it)
The || operator is a logical OR operator that lets you execute a second command iff the first
command fails (the exit status of the first command is greater than zero).
© 2015 Karen Reid
