Reference no: EM131857005

Programming Assignment - Writing a Unix Shell

Overview -

It is not the purpose of this assignment to write a fully functional UNIX shell. Rather, the purpose of this programming assignment is to introduce and familiarize ourselves to various concepts useful in systems programming such file I/O, processes control, and inter-process communication. As such, we will only code parts of the shell that help introduce these topics.

Assignment in brief -

This project consists of designing a C(or C++) program to serve as a shell interface that accepts user commands and then executes each command in a separate process. A shell interface gives the user a prompt, after which the next command is entered. The example below illustrates the prompt osh> and the user's next command: cat prog.c. (This command displays the file prog.c on the terminal using the UNIX cat command.)

The above is an example of a simple command i.e. it does not contain any operators. We will extend this program to execute more complex commands which contains one or more simple command connected together by an operator.

Evaluation and Points Distribution -

In order to evaluate your program, the program should implement to handle a switch '-t'. When used, the program does not print the prompt to the console i.e. disable all print statements when the -t argument is given.

The test scripts are used to test the program. The test can be executed by issuing the command:

osh -t < testscript.txt

The test file contains 9 test scripts, and the expected answer scripts. The table describes the test case, and the points awarded for each test case.

Detailed Discussion and Description -

This assignment is based on programming assignment Project 1 (part I) which is described on pg 157 of the text. We will not implement Part II of the project in the text. Instead we will extend the shell to support the file redirections, IPC (pipes) and command combinations described above. This assignment may seem daunting, so to help, it is broken into four phases.

Phase 1 - Parsing the Input String

The first step a shell should do is to parse the input line and figure out what it means. Mainly,

• identify the name of program
• supply the correct arguments to the program
• check if input or output needs to be redirected
• check if the output/input redirected from/to a file or another program
• check if there are any logical operator, which control the execution of programs
• repeat the same step for each command in the input

In order to achieve this, we need to

• correctly parsing the input line, by separating each token
• identify separate commands, and arguments for each command from tokens
• building a data structure to represent the parsed data
• save additional information (as to how it interacts with the next/previous command). This could be saving file handles, logical operator etc.

With this data structure, we should be able traverse the list with ease. Easily retrieve arguments, or skip to next commands etc.

Phase 2 - Forking a child process and executing a command

After building the data structure, start by executing simple commands (and ignore the operators for time being). Then extend the program to handle file redirection. This would involve

• extracting a simple command from the data structure (executable name and arguments)
• creating a new process for the executable mentioned in the command
• supplying correct arguments to the newly created process
• wait for the process to complete, collect exit code
• output the result to console (as of now, later we'll modify to handle redirector)

Phase 3 - Logical operators

Handling logical operators is super easy. The execution of the command is determined by the exit status of the previous command. In the previous section, we implemented the logic to collect the exit status. Let us break it down further,

• check if the previous command has any logical operator
• if it does, get the exit status of the previous command
• determine if you need to execute current command or skip it
• if you need to skip it, then set the exit status of the current command to be the same as previous command

The above logic, is sufficient to handle chains of logical operators.

Phase 4 - Pipes

This is the hard part, where you have to slay the dragon and rescue the Prince/Princess. We'll handle pipes in two steps. First we implement the logic to handle a single pipe, then extend it to handle any number of pipes in a command.

If you remember, a pipe works similar to a redirector. But unlike a redirector, where the input/output is a file, pipe connects two commands. So what does this mean? One way to think about it is that it is a concatenation of both input and output operator.

Attachment:- Assignment File.rar