The Details

Your shell must support the following:

1. The internal shell command "exit" which terminates the shell. Concepts: shell commands, exiting the shell System calls: exit()
2. A command with no arguments Example: ls Details: Your shell must block until the command completes and, if the return code is abnormal, print out a message to that effect. Concepts: Forking a child process, waiting for it to complete, synchronous execution System calls: fork(), execvp(), exit(), wait()

Your solution must also support the following:

1. A command with arguments Example: ls -l Details: Argument 0 is the name of the command Concepts: Command-line parameters
2. A command, with or without arguments, executed in the background using &. For simplicity, assume that if present the & is always the last thing on the line. Example: xemacs & Details: In this case, your shell must execute the command and return immediately, not blocking until the command finishes. Concepts: Background execution, signals, signal handlers, processes, asynchronous execution System calls: sigset()
3. A command, with or without arguments, whose output is redirected to a file Example: ls -l > foo Details: This takes the output of the command and put it in the named file Concepts: File operations, output redirection System calls: freopen()
4. A command, with or without arguments, whose input is redirected from a file Example: sort < testfile Details: This takes the named file as input to the command Concepts: Input redirection, more file operations System calls: freopen()
5. A command, with or without arguments, whose output is piped to the input of another command. Example: ls -l | more Details: This takes the output of the first command and makes it the input to the second command Concepts: Pipes, synchronous operation System calls: pipe()

Note: You must check and correctly handle all return values. This means that you need to read the man pages for each function to figure out what the possible return values are, what errors they indicate, and what you must do when you get that error.

Hints

1. You will need to make use of system calls such as execvp(), fork(), pipe(), wait() and dup2().
2. Assume the user enters ls lt | sort | more. Your shell would create a process for each command. A pipe must be created (using the pipe command) between the first and second process and the second and third process. Creating a pipeline between two processes is relatively simple (you have sample code for this), but the building of a multiple command pipeline is more difficult.
3. You may use any of the system calls found in the exec() family. If you use execvp, remember that the first argument in the array is the name of the command itself, and the last argument must be a null pointer.
4. A shell needs a command-line parser. The parser breaks down the string representing the command into constituent parts. These parts are referred to as tokens. To read a line from the user, you may use gets(). The parser you implement may use scanf(), strtok() or any other suitable C library functions. Parsing requires these steps:
   1. Read a line from standard input. You may use the gets() system call.
   2. A token is a sequence of non-whitespace characters that is separated from other tokens by whitespace characters. For each command line, you should form an array of tokens. This can be done using the strtok() system call. Example code is provided that takes a string and provides the tokens in an array.
   3. You should determine commands by analyzing the array created in the previous step. Any tokens between pipe signs are considered to be part of the same command.
5. Develop your code in incremental stages. One order of stages is the following:
   1. Write a shell that can fork single program invocations (with no arguments) and wait for their completion.
   2. Develop the command line parser.
   3. Extend the shell developed earlier to be able to handle arguments.
6. Add support for pipes

Your program must be developed using GNU versions of the C compiler running on Linux Ubuntu distribution. It should be layered, modularized and well commented. The following is a tentative marking scheme and what is expected to be submitted.

1. External Documentation including as many pages as necessary to fulfill the requirements listed below.
   1. Title page
   2. A table of contents
   3. [20%] System documentation
      1. A high-level data flow diagram for the system
      2. A list of routines and their brief descriptions
      3. Implementation details including information such as data structures and algorithms used.
   4. [5%] Test documentation
      1. How you tested your program
      2. Testing outputs
   5. [5%] User documentation
      1. Where is your source
      2. How to run your program
      3. Describe parameter (if any)

2. Source Code
   1. [65%] Correctness
   2. [5%] Programming style
      1. Layering
      2. Readability
      3. Comments
      4. Efficiency