CMSC421 Principals of Operating Systems Sections 0101/0201/0301

CSEE

             27 Nov 2002 at 11:59 pm for ten percent extra credit  25 Nov

Updated: 18 Nov

(c) 1997, Howard E. Motteler; Modified by Gary L. Burt, 2001

Project Goals

The Project

Shell

You are to design and implement a simple shell, "mysh". Some of the commands of this shell are to be internal and some are to external. The internal commands for project will be the command to list the directory (the UNIX "ls" command), the change directory command ("cd"), the user's date command ("date"), the history command ("history"), command to restart the client ("restartclient") and the "exit" command).

The following is a prototype of what your main might look like:

while ( TRUE )                            /* repeat forever           */
{
    read_command( command, parameters);   /* read input from terminal */

    /* Here you would have to check to see if                         */ 
    /* exit was entered and if it was, break out of the loop.         */
    if ( fork( ) != 0 )                   /* fork off child process   */
    {
       /* Parent Code                                                 */
       waitpid( -1, &status, 0 );     /* wait for child to exit       */
    }
    else
    {
       /* Child code                                                  */
        execve( command, parameters, 0 ); /* execute the command      */
        exit( 0 );                        /* when sucessful, there is */
                                          /* no return from execve    */
    }
}

Pipe and Sockets

There will be a 20% penatly if this part is not implemented!

On the client side, mysh will create a pipe and execute the program client. The client will wait until it receives a command on the pipe from mysh. Commands that it will be expected to handle are:

1. remoteput
2. remoteget
3. remotels

You will need to run a unique port number, so use 4XXXX, where "XXXX" is the last four digits of your SSN. If there are any programs, to 5XXXX instead, and document the change!

Sample of the socket code:

Specifications

cmd
cmd > file
cmd < file
cmd < file > file
cmd | cmd
cmd ; cmd
!!
!nr

where:

• "file" is any valid UNIX filename.
• "cmd" is a program name followed by zero or more options and by zero or more arguments.
• There will no wildcards, no in-line command evaluation, no macro substitutions, and commands and filenames include the symbols ">", "<", ";" or "|".
• There can be any of commands separated by the "|" or ";" tokens.
• There are internal and external commands. The external commands will by the ones you use fork and exec and get existing programs to execute. Internal commands will be handled by the program mysh by code that you must write:
  1. When "cmd" is exit, your shell should terminate.
  2. For the special case when "cmd" is "ls", ls -i, ls -a,ls -l, or li -li your shell will list the files for the directory given in the "file" argument. When there is no "file" specified, you are to use all of the current working directory. Your ouput will have the same appearance as the UNIX version of the same command. You will find the necessary information in the directory entry and the assocated inode struction.
  3. When the "cmd" is cd, your mysh must make the necessary system call in order for the cd to work correctly.
  4. When the "cmd" is remoteput, it will be followed with a filename (using either an absolute or relative pathname). mysh will send the file's contents to the socket-client via a pipe. Then the socket-client will transfer the contents to the socket-server. The socket-server will will save the contents to a file with the same name.
  5. When the "cmd" is remoteget and a filename, mysh will send the name to the socket-client, which will request the file from the socket-server. The socket-client will save the file's contents in the current working directory.
  6. When the "cmd" is remotels, mysh will request the a listing of the directory on the other side of the socket. It will be assumed that all work will be done in only one directory on the socket-server.
  7. When the "cmd" is "restartclient", mysh will execute the socket-client software.

  You must provide error-handling for all internal commands, similiar to how Linux does it. (For external commands, you can let Linux message print out, so you don't have to do any extra work for that!) Transfer to data must be coordinated using a semaphore!

• Your shell should also be able to parse and execute command lines above ending with an "&" that puts the specified process or processes into the background. (With multiple commands, only put put the last command into the backgroud.)
• You can assume that all command lines are of the form described here, and you do not have to check for any other sorts of input. In particular, you do not have to expand filename wildcards.
• Use fork() and either execl(), execve() or execvp() to execute the commands. The main difference is that execvp() will search your PATH for the specified executable, and doesn't have an explicit environment argument. Additional information about these calls is available from the man pages.
• Your shell should prompt the user for each command line with the string "mysh[n]>". The number n is the number of the command )(for the history version). You must have a history buffer for at least 50 commands and this history must be carryed over to the next use of "mysh"
• Your date command must allow the user to format the date output in the same way UNIX does. You must not attempt to set the date on the system since this is a privileged command. You can limit the formatting to only printing out the name of the day, the number of the day in the month, the name of the month, full year and the time as hour, minute and seconds. (Hint: look at the man page for strftime( ).
• Your shell will allow two forms of the history command. The first is the double explanation points ("bang-bang") which will repeat the last line of input that was typed in. The second version is the explanation point with a number ("bang-n") . The number is a command from the history buffer. You will be required to keep the last fifty commands in the buffer, and know the history number of each command. If the user enters an invalid number, output an appropriate error message and advance to the next command.
• The final version you submit should not print any test messages or other extraneous jabber. You should print errors returned by execvp() or execve(); you can use strerror(errno) to make your error reporting more informative; errno is an external variable set to the most recent error, and strerror() translates this to a human-readable string. You may find the UNIX string manipulation library routines (such as strtok) convenient for parsing the command line; do a "man string" to learn more about these functions.
• To redirect input from a file to a program, so the file appears as "standard input" to the program (e.g., as in the command " wc < test.dat"), you will have:
  1. to manipulate file descriptors. To connect a file to the UNIX "standard input" (by convention file descriptor 0), you can use the dup2()system call, as in the following example.

     
     
     if (( fd = open ( fname, O_RDONLY )) == -1 )
     {
         fprintf( stderr, "mysh error: can't open %s\n", fname);
         exit(1);
     }
     
     dup2(fd, 0);
     close(fd);
     
     if(execvp(cmd, args == -1 )
     {
         fprintf(stderr, "mysh error: %s\n", strerror(errno) );
     }
     

  2. OR you can use a real pipe (see system call for pipe).
  When you have redirection, make sure to do it in the child and not the partent!

• If we wanted to execute the command "wc -l", "cmd" in the above example would be the string "wc", and the string array "args" would have its first element pointing to "wc", its second element pointing to "-l", and its third element the null pointer 0, indicating the end of the arg array.
• The "&" function is easy to implement--without the "&", the shell waits for the child process; with the "&" it does not wait.
• The pipe function "|" is a little more difficult, and can be implemented with either a temporary file, or preferably with a real UNIX pipe.
• The ";" is used to separate commands on the command line. Process the first part independently and when it is finished, then process the second part.

Extra Credit Feature

Single Quote

Double Quote

echo "$HOME"
/home/faculty1/burt

Single Back Quote

Exampele:

burt[103]: echo `whoami`
burt

Another example is:

burt[105]: echo "It is currently `date`"
It is currently Wed Nov 13 17:01:06 EST 2002

The command

burt[106]: finger `whoami`
Login: burt                             Name: Gary Burt
Directory: /home/faculty1/burt          Shell: /bin/csh
Never logged in.
New mail received Wed Nov 13 16:37 2002 (EST)
     Unread since Tue Nov 12 17:12 2002 (EST)
No Plan.

A final example is:

echo "You have `ls | wc -l` files in this directory."

Grading

The coding standard and indentation standards must be following and compliance will be part of the 20% for documentation!

There are 40 commands that I have given to the TAs to be used when grading the project that will make up the other 80%.

Do not use the system( ) system call or invoke the UNIX shell to implement your shell!
Doing so will earn you a zero on the project!

You must do the project described here. Doing some other similar or dissimilar project, matter how difficult or clever, may be worth 0 points. This is not a group project; please do your own work, and be careful about sharing your code. It is OK to discuss design issues, but in your documentation, you should give credit to your sources.

You will be provided with a copy of the test plan that the TAs will use when the grade this project, so that you will know exactly how they will test this project. However, you must make sure that you can meet all the requirement in any of the prescribed forms! The TA will be allowed to run any commands necessary to give the proper grade. You can not limit you programs to just those commands on the webpage, either!

What to turn in

Put all of the required files into a tar file and

When your project is absolutely finished and you have completely and totally tested your work, you are to submit the project tar file for grading using the digital dropbox in Blackboard.

It is important that your tar file be named with the last four digits of your SSN and "prj2". If the last four of your SSN were 6789, then the file name would bd:

Hints and Tips

• The best place to look for how to use the different library routines is Advanced Programming in the UNIX Environment, by Stevenson.
• To get started, you should read the man pages for fork, execl, execve, execvp, dup, wait, pip, getpid and any string functions you might want to use. ("man string" will bring up a summary page on the basic string functions.)
• The functions execve and execvp take an array of strings as their arguments. This array is similar to the argv[] array passed to C programs. When you create this array, it is important that the end of the array is marked with a null pointer (Not a null string!); for example if there are k string pointers in your array args, you would set args[k]="\0".
• You will probably need the following "include" files.
  
  

          #include <stdio.h>
          #include <unistd.h>
          #include <sys/types.h>
          #include <sys/stat.h>
          #include <fcntl.h>
          #include <string.h>
          #include <stdlib.h>
          #include <errno.h>
          #include <netinet/in.h>
          #include <sys/socket.h>
          #include <sys/wait.h>
          #include <netdb.h>
          #include <sys/ipc.h>
          #include <sys/sem.h>
          #include <sys/shm.h>
        

• You should develop your code in a series of stages, such as:
1. write and test a parser to read the command lines;
2. get the simple commands to work;
3. get the history portion to work;
4. get "&" to work;
5. get I/O redirection to work;
6. get the cd command to work;
7. get pipes to work.
8. remote commands
• When working with a file version of a pipe, you will have to capture the output from the first command in a temporary file. You can store the file in the directory /tmp, which is for that purpose. However, you will have to make sure that your filename is unique. Since you might have a file in that directory left over from an earlier session, so you need a way to guarantee a unique filename. You can use your login ID plus the PID of the current process. Also remember to remove the file when it is no longer needed!

  When working with the system pipe, remember to remove the pipe when terminates (whether it was intended or not).

• This project is to be Linux-only. It should run on all versions of UNIX, but there is not enough time to worry about it.
• This is a non-trivial program. Do not wait to start implementation because you will not have enough time if you do.

UMBC   |   CSEE