Introduction

In this project you will gain some practice using the C++ fork, wait and execv system calls for creating new processes and running programs. In addition, you will extend the functionality of a C++ program that implements a command line shell.

Resources

You will be writing your programs for this project using C++. The sample programs presented in class, plus the links provided here will be good resources for completing this project.

Sample Programs:

• ConsoleIODemo.cpp - Demonstration of console input/output in C++.
• StringDemo.cpp - Demonstration of string functions in C++.
• StringConvert.cpp - Demonstration of converting a C++ string into a C-style string.
• TokenizeString.cpp - Demonstration of using the functions in StringTokenizer.cpp to split a C++ string into its tokens.
• ForkDemo.cpp - Demonstration of using the fork and wait system calls in C++.
• ExecvDemo.cpp - Demonstration of using the fork, execv and wait system calls in C++.

Links:

• C++ Strings - a page listing and describing all of the C++ string functions.

Compiling and Running C++ Programs

To compile a C++ program use the command line:

g++ <source file> -o <executable file>

For example, to compile the ForkDemo.cpp program the command line would be:

g++ ForkDemo.cpp -o ForkDemo.exe

Note that unix does not require the .exe extension on an executable file. I've used it here just to clearly distinguish between the source and executable versions of the programs.

To run a compiled C++ program, be sure you are in the directory containing the file and then use the command line:

./<executable file>

For example, to run the ForkDemo.exe program that was compiled above, you would use the command line:

./ForkDemo.exe

Part 1 - fork, wait and execv

In this part of the project you will write several programs that make use of the fork, wait and execv system calls in C++.

1. Write programs A.cpp, B.cpp, C.cpp, D.cpp, such that when program A is run the following process tree is created:
   A / \ B C / \ \ D C D \ D

   Every process should wait for all of its children to complete. Note process D doesn't fork any other processes. It should just announce that it is running, sleep for a little while and then announce that it is done. If you have D sleep for long enough you will be able to use the ps command to verify that you have created the correct process tree.

   The output from running program A should be similar to the following:

   Process A running Process C running Process D running Process B running Process D running Process C running Process D running Process D done Process C done Process D done Process D done Process C done Process B done Process A done
   Turn in printouts of your 4 programs as your answer to this question. (Save backup copies, because the next several questions ask you to make some changes to these programs.) Question to think about for discussion in class: can you guarantee that the output will be exactly as given above? If not, why not?
2. Answer the following questions by modifying your programs from #1 and using the ps command. You will need to use calls to the sleep method in your processes so that you have time to observe the results using ps. You will also need to use some of the options to the ps command in order to see PPID information as well as all system processes (you will be particularly interested in the init process.) Do not turn in programs for this part. In your answers just explain how you modified prgrams C and D, what you did in order to answer the question and what you found.
   1. What happens to process D if you kill process C while it is waiting for process D to complete?
   2. What happens to process C if process D is killed while process C is waiting on it?
   3. What happens to process C if process D completes naturally before process C waits on it?
   4. What happens if process C exits normally while process D is still running?
   5. Based on those observations. What do you think would happen if you ran process A and it were killed while waiting for its child processes B and C? Check your expectations and describe what happens.
   6. What happens if you kill the process for the command shell from which process A was run while process A is still running? Why do you think this is different?

Part 2 - Exending the SimpleShell

The program contaned in the file SimpleShell.cpp contains the beginnings of a shell program. As suggested by its name, the functionality of the SimpleShell is very limited. It will read a single line of input from the user and attempt to execute that line as a program using fork and execv. So for example, if the user were to enter the command:

/bin/ls -l

In response to this command, the SimpleShell will execute the ls program contained in the /bin directory and pass it the command line argument -l. After executing the command, the SimpleShell simply exits. You should play with the SimpleShell program for a little while until you get a feel for what it can and cannot do. Some things you should be sure to try are: entering a bogus command, changing directories, running a program (like ls) without specifying its full path, and running a program in the current directory.

Your job for this part of the project is to extend the functionality of the SimpleShell in the following ways:

• Have the shell read and attempt to execute commands from the user until the user enters the exit command.

• Add the & functionality. That is, if a command that is entered ends with an & then the command should be run concurrently with the shell. Otherwise, the shell should wait for the entered command to complete.

• Implement the cd command so that the user can change the current working directory. Using cd without any argument should cause the current working directory to be set to the user's home directory as indicated by the HOME variable. To change the current working directory you will need to make use of the chdir system call. The code below shows several examples of how to use this system call:
  char *newAbsDir = "/usr/local/bin"; int rv = chdir(newAbsDir); // change cwd to /usr/local/bin // rv will be 0 if the directory was changed and -1 if not. char *newRelDir = "stuff"; rv = chdir(newRelDir); // Change into "stuff" subdirectory // of the current directory. char *newParentDir = ".."; rv = chdir(newParentDir); // change into the parent directory.

• Implement PATH functionality. When the user enters a command with no path specified (e.g. ls -l) the shell should attempt to run a program with the specified name in each of the directories listed in the PATH. The directories in the PATH are to be tried in the order that they appear. If the program is not found in any of the directories contained in the PATH, then an appropriate error message should be displayed. NOTE: If the user enters a command containing either an absolute or a relative path, then the PATH should not be seached.

To submit part 2 of this project, send all of the source code files for your shell (with comments please) to me as an e-mail attachment.

Bonus Features

Each of the following features can be implemented for bonus points:

• Change the program so that the values for the PATH and HOME environment variables are read from a file when the shell is started.

• Add a history feature to your shell. The history feature should allow the user to recall and execute commands that had been previously entered without retyping them. In the bash shell, the history is accessed using the up-arrow key. Your history may be accessed that way or any other way that you like. Just include directions for how to use your history feature in a comment at the top of your shell code.

Acknowledgment: this content is essentially identical to that developed by Professor Grant Braught for the Spring 2006 Operating Systems course, and I'm grateful for his permission to use it.

---