CS 232 Project 3 at Calvin College

CS 232 Project 3: A Command Shell

Overview.

A shell is a program that repeatedly:

reads a user command from the keyboard; and
performs that command on behalf of the user.

Your task in this 2-person group assignment is to write your own xyshell program, where x and y are the first initials of the people in your group.

Details.

This project is to write an object-oriented C++ shell program. Each non-trivial object in the project should be written as a class. Your driver program for the project should be no more complicated than this:

   #include "XYShell.h"
   int main()
   {
      XYShell myShell;
      myShell.run();
   }

One possible breakdown of the functionality is as follows:

XYShell - your shell class, with two public methods:
- XYShell() - initialize your shell; and
- void run() - execute your shell.
In addition to executing system programs (e.g., ls, ps, pwd), your shell must also handle cd and pwd as built-in commands (you may find the chdir() and getcwd() system calls to be useful for this).
CommandLine - a class to read a command-line, with these public methods:
- CommandLine(istream& in) - construct a CommandLine by reading a command-line from in, parsing it, and building instance variables for argc and argv (you may find the calloc() and free() system calls to be of use here).
- char* getCommand() const - return a pointer to the command portion of the command-line (i.e., argv[0]).
- int getArgCount() const - return the number of command-line arguments on the command-line (i.e., argc).
- char** getArgVector() const - return a pointer to a char* array, each entry of which points to one 'word' of the command-line (i.e., argv).
- char* getArgVector(int i) const - return a pointer to the ith (zero-relative) command-line 'word' (i.e., argv[i]).
- bool noAmpersand() const - returns true if and only if no ampersand was given on the command-line
Path - a class to represent the directories in which your shell searches for executable programs, with these public methods:
- Path() - construct a Path from the PATH environment variable, by storing each directory in PATH in a vector<string> (you may find the getenv() system call to be of use).
- int find(const string& program) const - return the index of the directory containing program, or -1 if program is in no directory (you may find the opendir(), readdir(), and closedir() system calls to be of use here).
- string getDirectory(int i) const - return the name of the directory whose index is i.
Prompt - a class to represent the command-line prompt, containing these public methods:
- Prompt() - a constructor that builds a Prompt as the full path to the working directory (you may find the getcwd() system call to be of use).
- string get() const - an accessor that returns the current value of the Prompt.

You should feel free to create other classes as you need them. You may also define additional methods in each of these classes. Methods that define messages to be sent to class objects should be implemented as public methods; methods used to define class utilities or break a big method into more manageable pieces should be defined as private methods. Stylistically, no method should be more than a half-page in length. Remember: Any class that allocates memory dynamically should provide a destructor to reclaim that memory, to avoid leaking memory.

To execute system programs, your shell should use the fork(), waitpid(), and execve() system calls: The fork() call clones the current process to create a child process that is a complete copy of its parent. The child process should then use execve() to execute the user's command.

If no ampersand has been given on the command-line, the parent should use waitpid() to wait until the child terminates; otherwise (an ampersand was given, indicating the command was to be run in the background), it should return to the top of its loop, prompt the user, and await their next command. You may also find the sched_yield() system call to be useful in synchronizing the parent and child processes.

You should read the UNIX manual pages (section 2) for the details of the various system calls listed above, especially what header files must be #include-d to use them. There are also may be WWW tutorials/examples available that you may find useful.

To illustrate:

   $ ./xyshell

should run your shell, which then displays its prompt and awaits a user command:

   /home/adams/proj/shell/$

When the user types a command, the program should perform that command and then prompt for the next one:

   /home/adams/proj/shell$ ps
     PID TTY          TIME CMD
     2208 pts/2    00:00:00 bash
     2428 pts/2    00:00:00 xyshell
     2485 pts/2    00:00:00 ps
   /home/adams/proj/shell/$

If the user types a command with an ampersand, the program should not wait before prompting for the next command:

   /home/adams/proj/shell$ ps &
   /home/adams/proj/shell$
     PID TTY          TIME CMD
     2208 pts/2    00:00:00 bash
     2428 pts/2    00:00:00 xyshell
     2485 pts/2    00:00:00 ps

Extra Credit.

Design and build an Environment class that captures your shell's environment, so that you can run X-Window programs. When your child process invokes execve(), send your Environment class a message that returns a char** vector containing the enviroment, and pass that vector as the third argument to execve().

Plan of Action.

0. Divide the work between you and your partner. One person should be responsible for the CommandLine class and the other should be responsible for the Path and Prompt classes. You should aim to have these classes done at the end of the first week. You should work together the second and third weeks to build your XYShell class integrating the other classes.

1. The person building CommandLine should read up on argc and argv (these are covered in C++ An Introduction to Computing most C books, and a number of on-line sites), as well as the system calls that are useful for this class. Then implement the class.

2. The person building the Path class should read up on the system calls it uses. Then implement the class. Then do the same for the Prompt class.

3. Together, read up on fork(), execve(), and waitpid(). Design the algorithm for your run() method; then build your XYShell class (replacing X andY with your initials). cd and pwd are the only built-in shell commands your shell needs to recognize.

Feel free to discuss the project, the Unix manual pages, and the system calls with myself or your classmates. You are not to look at anyone else's source code.

Your program should be reasonably efficient in terms of its use of both time and space. It should also be fully documented, with an opening (header) comment that gives all of the usual information (who, what, where, when, and why), descriptive identifiers, judicious use of white space, and in-line comments explaining any 'tricky' parts.

Turn in: A project gradesheet, stapled to a script file, in which you

Use cat to list each file in your program;
Use make to successfully compile your program; and
Exercise your program as necessary to show its functionality (e.g., ls, cd .., pwd, ls -a, ls -l /home, pwd, ps -ax &, etc.). Include at least one invalid command to show that your program handles such commands gracefully.

On your hard copy of the script file, please highlight each command your shell executes, so that the grader can find them easily.

In order for your project to be graded, each person in your group must sign the project grade sheet, and the group must collectively indicate what "fair share" percentage of the work each person did. (If a person did their "fair share" of the work, put 100% for that person.)

Due date: Wed, Mar 28, 11:59 p.m.

Calvin > CS > 232 > Projects > 3

This page maintained by Joel Adams.