Smart Shell, Part II

You may work alone or with one other classmate, and each person is expected to contribute equally to the effort.

Introduction

• In this programming assignment, you will delve into the details of loading and running executable files, then extend your smart shell to run other executable modules.

• If needed, a complete working version of the first part of the smart shell will be provided as a starting point.

Standard system function

    int system(const char * command);

Your own mysystem function

The first goal of this assignment is to write your own mysystem function with the prototype:

   void mysystem(const char * command);

    execv(char * fullcmd, char * cmdargv[]);

In building the full command for execv, you will make use of the global variable searchpaths built by the function tokenize_PATH from your previous assignment.

What To Do

1. In your systems directory there is another directory called smartshell. Make a copy of this directory using the command

       cp -r ~/systems/smartshell ~/systems/smartshell-one
   

   Verify that the new directory has been successfully created (use ls). The solution to this assignment should be in the directory ~/systems/smartshell.

2. Add to smartshell.c code for a new function

      void mysystem(char * command)

   that mimics the behavior of the standard system function. Your code should implement the following steps:

   • Check to make sure that command is not NULL. If it is, do nothing (simply return).

   • Tokenize command using the delimiter string " \n" (which includes the null character and the space character and the newline character). You will need to save each command token into an array of strings, say cmdargv. For example, if command is "gcc mysh.c -o sh", then cmdargv should look as in the diagram below.

     

   • The name of the program to execute is the first token in the command. You saved it in cmdargv[0]. The next step is to find this executable in one of the directories listed in the PATH environment variable. For each such directory, you will need to build the full path for the executable by appending the executable name to the directory name. For example, if the first directory listed in PATH is "/bin", then we try the full path "/bin/gcc". If this command fails, then we continue looking in the second directory, and so on. We will build our full path in a dynamically allocated buffer

         char * fullcmd;
     

     To implement this step, spawn a child process using fork. In a loop, the child process will be an exact copy of the calling process. The child process scans searchpaths and uses each entry i as follows:

     • (a) Allocate enough memory for fullcmd to hold the full path for the command:

           fullcmd = (char *)malloc(strlen(searchpaths[i]) + strlen(cmdargv[0]) + 2);
       

     • (b) Build the full path as if the executable were located in searchpath[i] (which we do not yet know):

           sprintf(fullcmd, "%s/%s", searchpaths[i], cmdargv[0]);
       

     • (c) Invoke execv to replace the currently executing program with the image of the command to be executed:

           execv(fullcmd, cmdargv);
       

       If the executable fullcmd exists, then execv succeeds and your child process ends (because the child code, which includes this loop, gets overwritten by the code of the executable cmdargv[0]). If the executable fullcmd does not exist, then the child continues with the instruction following the execv call. This instruction must free the memory dynamically allocated in this iteration, in preparation for the next loop iteration:

           free(fullcmd);
       

     • (d) Proceed with the next loop iteration.
   • The parent waits for the child to finish execution, then returns (so the function mysystem ends).

   • You may use this code as a starting point.

   Note: You may not use calls to execvp or exceve in implementing the mysystem function.

3. Test out the functionality of the mysystem function before moving on to the next step. For example, you may comment out the code for the existing main function, and simply add to main one line of code similar to

       mysystem("ls -a"); 

   The output should be identical to the one obtained by typing ls -a at the shell prompt.

4. Once you have convinced yourself that the mysystem works as expected, you may use it in the main loop from the previous assignment. Invoke mysystem on all user commands other than path, where and quit (which should be handled as in the previous assignment).

5. Compile as in the previous assignment using the command

       gcc smartshell.c stringarray.c -o xsmartshell
   

   The two source files will be linked into one executable file called xsmartshell.

   To simplify your development process, you may use this Makefile and simply type in make at the shell prompt to compile your code. This saves you from typing in a long command line every time you need to compile your code.

   Makefiles are special format files that help build and manage projects composed of multiple modules. The key point to remember is that you need to insert a TAB character (not spaces) before each command in the Makefile. If interested, you may read more about using make and writing Makefiles.

Important Notes

• Debug NOW, not later:
  • It is difficult to: write entire program; test entire program; debug entire program
  • It is easier to: write a little; test a little; debug a little; write a little; test a little; debug a little; ...

• Maintain previous versions:
  • It is difficult to: change code; note bug; try to remember what changed since last working version!!!
  • It is easier to: backup code; change code; note bug; compare new version with last working version to determine what changed

• Your code must compile:
  • No credit will be given for code that does not compile. Keep copies of intermediate versions of your programs, and if you do not have time for last minute debugging, submit the last version that compiled and produced some results. It is better to submit a program that works than one that crashes, even if you have not implemented all the required features.

Submission Instructions

1. Your name(s) and assignment number.
2. The machine you used to complete the assignment (i.e, tanner or your own machine). If you used your own machine, please be ready to demo your code to your TA or your instructor at any time upon request.
3. A description of whatever help (if any) you received from others outside of class.
4. An indication of how much time you spent doing the assignment outside of class.
5. Your assessment of the assignment: Did it help you to learn? What did it help you to learn? Do you have any suggestions for improvement? Etc.
6. Any information that will help us to grade your work in the most favorable light. In particular you should describe all known bugs.

Turn in a printout copy of the readme and smartshell.c files, and a sample output (one printout per team). If you work on the department Unix system, you will need to copy and paste your code into a text or a Word document in Windows, since you cannot print directly from Unix.

Leave the source code for all exercises in your directory systems/smartshell. Do not make any changes to these files after the due date for this assignment. If you wish to continue working on these exercises after the due date, make a copy of your directory smartshell using the following Unix command:

    cp -r ~/systems/smartshell ~/systems/smartshell-copy2

Grading

Have fun!