Question

This project consists of designing a 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 cse222> and the user’s next command: cat prog.c.

cse222> cat prog.c

One technique for implementing a shell interface is to have the parent process first read what the user enters on the command line (in this case, cat prog.c), and then create a separate child process that performs the command. Unless otherwise specified, the parent process waits for the child to exit before continuing. However, UNIX shells typically also allow the child process to run in the background, or concurrently. To accomplish this, we add an ampersand (&) at the end of the command. Thus, if we rewrite the above command as

cse222> cat prog.c &

the parent and child process will run concurrently.

The separate child process is created using the fork() system call, and the user’s command is executed using one of the system calls in the exec() family.

A C program that provides the general operations of a command-line shell is supplied below. The main() function presents the prompt cse22> and outlines the steps to be taken after input from the user has been read. The main() function continually loops as long as should_run equals 1; when the user enters exit at the prompt, you program should set should_run to 0 and terminate.

#include <stdio.h>

#include <unistd.h>

#define MAX_LINE 80 /* The maximum length command */ int main(void)

{

char *args[MAX_LINE/2 + 1]; /* command line arguments */

int should_run = 1; /* flag to determine when to exit */

while(should_run){

printf(“cse222>”);

fflush(stdout);

/**

*After reading user input, the steps are:

*(1) fork a child process using fork()

*(2) the child process will invoke execvp()

*(3) if command include &, parent will invoke wait()

*/

}

return 0;

}

You need to modify the main() function so that a child process is forked and executes the command specified by the user. This will require parsing what the user has entered into separate tokens and storing the tokens in an array of character strings (args). For example, if the user enters the command ps –ael at the cse222> prompt, the values stored in the args array are:

arg[0] = “ps”

arg[1] = “-ael” args[2] = NULL

The args arrary will be passed to the execvp() function, which has the following prototype:

execvp(char *command, char *params[]);

where command represents the command to be performed and params stores the parameters to this command. For this project, the execvp() function should be invoked as execvp(args[0], args). You should check whether the user includes an & to determine whether or not the parent process is to wait for the child to exit.

Answer 1

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

#define MAX_LINE 80 /* The maximum length command */

void invoke_error(char *a) {
   printf("rsh: %s (~.~)! \n", a);
}

int fetch_input(char *a) {
   char p;
   int num = 0;

   while (((p = getchar()) != '\n') && (num < MAX_LINE)) {
       a[num++] = p;
   }

   if (num == MAX_LINE && p != '\n') {
       invoke_error("Command exceeds maximum command length");
       num = -1;
   } else {
       a[num] = 0;
   }
   while (p != '\n') p = getchar();
   return num;
}

void print_history(char history[][MAX_LINE + 1], int history_count) {
   if (history_count == 0) {
       invoke_error("No history yet");
       return;
   }

   int i, j = 10;
   for (i = history_count; i > 0 && j > 0; i --, j--) {
       printf("%4d\t%s\n", i, history[i % 10]);
   }
}

int parse(char *buffer, int length, char* args[]) {
   int args_num = 0, last = -1, i;
   args[0] = NULL;
   for (i = 0; i <= length; ++i) {
       /* The last one must be zero so use <=*/
       if (buffer[i] != ' ' && buffer[i] != '\t' && buffer[i]) {
           continue;
       } else {
           if (last != i-1) {
               //store the parse result of [last+1, i-1]
               args[args_num] = (char*)malloc(i-last);
               if (args[args_num] == NULL) {
                   invoke_error("Unable to allocate memory");
                   return 1;
               }
               //malloc size+1
               memcpy(args[args_num], &buffer[last+1], i-last-1);
               //
               args[args_num][i-last] = 0;
               //set the last char zero
                   args[++args_num] = NULL;
           }
           last = i;
       }
   }
   return args_num;
}

int to_number(char *a) {
   int length = strlen(a), i, answer = 0;
   for (i = 0; i < length; i++) {
       if (a[i] > '9' || a[i] < '0') return -1;
       answer = answer * 10 + a[i] - '0';
   }
   return answer;
}

int main(void) {

  

   char *args[MAX_LINE/2 + 1]; /* command line arguments */
   int should_run = 1; /* flag to determine when to exit program */

   char history[10][MAX_LINE + 1];
   int history_count = 0;

   char buffer[MAX_LINE + 1];
   memset(buffer, 0, sizeof(buffer));
   int length, args_num;

   while (should_run) {
       printf("rsh>");
       fflush(stdout);

       /**
       * After reading user input, the steps are:
       * (1) fork a child process using fork()
       * (2) the child process will invoke execvp()
       * (3) if command included &, parent will invoke wait()
       */

       length = fetch_input(buffer);
       if (length == -1) continue;

       if (strcmp(buffer, "!!") == 0) {
           if (history_count > 0) {
               memcpy(buffer, history[history_count % 10], MAX_LINE + 1);
               length = strlen(buffer);
           } else {
               invoke_error("No commands in history");
               continue;
           }
       }

       args_num = parse(buffer, length, args);

       if (args_num == 0) continue;
       //No input message

       if (strcmp(args[0], "!") == 0) {
           int temp = to_number(args[1]);
           if (temp <= 0 || temp < history_count - 9 || temp > history_count) {
               invoke_error("No such command in history");
               continue;
           } else {
               memcpy(buffer, history[temp % 10], MAX_LINE + 1);
               length = strlen(buffer);
               args_num = parse(buffer, length, args);
           }
       }

       if (strcmp(args[0], "exit") == 0) {
           should_run = 0;
           continue;
       }

       if (strcmp(args[0], "history") == 0) {
           print_history(history, history_count);
           continue;
       }

       history_count ++;
       memcpy(history[history_count% 10], buffer, MAX_LINE + 1);

       //printf("%s\n", args[0]);
       //here to implement the new order

       int background = 0;
       if (strcmp(args[args_num-1], "&") == 0) {
           background = 1;
           args[--args_num] = NULL;
       }

       pid_t pid = fork();
       if (pid < 0) {
           invoke_error("Fork process error");
           return 1;
       }

       int status;

       if (pid == 0) {
           status = execvp(args[0], args);
           if (status == -1) {
               invoke_error("Failed to execute the command");
           }
           return 0;
       } else {
           if (background) {
               printf("pid #%d running in background %s\n", pid, buffer);
           } else {
               wait(&status);
           }
       }

   }

   return 0;
}