Shell Code

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

#define BUFFER_LENGTH 1024
#define TOKEN_LENGTH 255
#define TOKEN_DELIMETERS " \t\n\a\r"
#define MAX_QUEUE 10

int pid_queue[MAX_QUEUE];
int front = -1;
int rear = -1;
int skip_input = 0;

/*Function: read_string
 *Parameters: void - It accpets no parameter as this method is used to read input string.
 *Returns: String of characters enter by user.
 *Description: It read the the command  entered by msh shell user
 *and copy it in variable name "command" and retrun it to its calling function.
 */

char *readString(void)
{
        int buffer_size = BUFFER_LENGTH;
        //parse and store
        char *command = malloc(sizeof(char) * buffer_size);
        memset(command,0,BUFFER_LENGTH );
        if(!command)
        {
                exit(EXIT_FAILURE);
        }

        while(1)
        {
        //takes user input
                if( fgets(command,BUFFER_LENGTH,stdin) == NULL ) return NULL;
                        size_t length = strlen(command);
                // replace the end of the file with the null character
                if(command[length-1] == '\n')
                {
                        command[length-1] = '\0';
                        return command;
                }
                        return command;
        }
}

/*Function: split_command
 *Parameter(s):command- A pointer to string of character contains user command
 *Returns: Pointer to Array of String contains tokens of string of user command
 *Description: Tokenizes the user command once " \t\n\r" delimeters are found
 *and put different token into different index of string array.
 */

char **split_command(char *command)
{
int buffer_size = TOKEN_LENGTH;
char **tokens = malloc(buffer_size * sizeof(char*));
char *token;
token = strtok(command,TOKEN_DELIMETERS);
int i = 0;
// tokenize the user command to treat it like separate strings.
while(token!=NULL)
{
        tokens[i]=token;
        i++;
        token = strtok(NULL,TOKEN_DELIMETERS);
}
        tokens[i] = NULL;
for (i =0; i<sizeof(tokens); i++){
printf("%s",tokens[i]);
}
return tokens;

}


void insertPid (int pid_child)
{
        //condition to check if queue is full.
        if(rear >= MAX_QUEUE - 1)
        {
          front = front + 1;
        }
        if(front == -1)
           front = 0;
           rear = rear+1;
           pid_queue[rear] = pid_child;
}


/*Function: showpid
 *Parameters: void
 *Returns: void
 *Description: Display  all the process id present in the pid_queue
 */

void showpid()
{//checking the error condition for showpid().
if (front == -1 || front == rear+1)
{
        printf("No process spwaned by your shell\n");
        return;
}
int i;
for(i=front;i<=rear;i++)
        {
        printf("%d\n",pid_queue[i]);
        }
}

/*Function: read_msh
 *Parameters: cmd - A pointer to string array. Contains token of the command
 *entered by the user
 *Returns: An integer value of 0 for success and -1 for error
 *Description: It process the user input command and fork a child process and execute the command
 *It aslo search for user program in different directory.
 */

int run_msh(char **cmd)
{
pid_t pid;
int status;
char cmd_str[20];
int *shw_pid[MAX_QUEUE];
int front = -1;
int rear = -1;

while(1){

        if( cmd[0] == '\0' ) return 1;

        // check for the user input to exit the program
                if((strcmp(cmd[0],"exit")== 0) || (strcmp(cmd[0],"quit") == 0))
                {
                        exit(1);
                }

                //Change Directory commamnd.
                else if(!strcmp(cmd[0],"cd"))
                {
                        if(cmd[1] != NULL){
                        chdir(cmd[1]);
                }
                return 1;
                }

                //when user enters showpid.
                else if(!strcmp(cmd[0],"showpid"))
                {
                        if(cmd[1] == NULL)
                {
                showpid();
                return 1;
                }
                else
                {
                        printf("Wrong Command: Try only showpid\n");
                        return 1;
                }
                }
                else
                {
                pid = fork();

                if(pid == 0)
                {
                        char cmd_str[20];
                        memset(cmd_str,0,20);
                        strcpy(cmd_str,"./");
                        strcat(cmd_str,cmd[0]);

                int i;
                //for(i=0;i<strlen(cmd_str);i++)
                //{
                //      if(cmd_str[i]=='\n'){
                //      cmd_str[i] ='\0';
                //}
                //}

                //check inside every given directory and handle ls.

                if(execl(cmd_str,cmd[0],cmd[1],cmd[2],cmd[3],cmd[4],cmd[5]) == -1)
                {
                        memset(cmd_str,0,20);
                        strcpy(cmd_str,"/usr/local/bin/");
                        strcat(cmd_str,cmd[0]);

                  if(execl(cmd_str,cmd[0],cmd[1],cmd[2],cmd[3],cmd[4],cmd[5]) == -1)
                {
                        memset(cmd_str,0,20);
                        strcpy(cmd_str,"/usr/bin/");
                        strcat(cmd_str,cmd[0]);

                   if(execl(cmd_str,cmd[0],cmd[1],cmd[2],cmd[3],cmd[4],cmd[5]) == -1)

                {
                        memset(cmd_str,0,20);
                        strcpy(cmd_str,"/bin/");
                        strcat(cmd_str,cmd[0]);


                        if(execl(cmd_str,cmd[0],cmd[1],cmd[2],cmd[3],cmd[4],cmd[5])== -1)
                  {
                        printf("%s: Command not found\n",cmd[0]);
                        return 0;
                  }
                }
                }
                }
                }
                else
        {
                insertPid(pid);
                wait(&status);
                return 0;
        }
    }
  }
}

/*Function: initialize_shell
 *Parameters: void
 *Returns: An integer 0 on success and -1 on failure
 *Description: It initialize all the methods available in shell and process the user command
 * and return ineger value.
 */
int initialize_shell(void)
{
        char *input_string;
        char **command;
        int status;
while(1)
{
        printf("msh>");

        input_string = readString();            // call readString method to read all string
        if( input_string == NULL )
        continue;
        command = split_command(input_string);  // call for split_command function which tokenize user command
        status = run_msh(command);              // call for run_msh function

        free(input_string);                     // releasing memory
        free(command);                          // releasing memory
}
return 0;
}


/*Function: handle_signal
 *Parameters: int
 *Returns: void
 *Description: This will handle signal interupt
 */
static void handle_signal(int sig)
{
  skip_input = 1;
}

/*Function: main
 *Parameters: void
 *Returns: int
 *Description: this function is responsible to handle signal and to intialize all other
 *function of this codw
 */

int main()
{
        struct sigaction act; // Created structure
        memset(&act,0,sizeof(act));
        act.sa_handler = & handle_signal;

        if(sigaction(SIGINT, &act, NULL)< 0)
        {
                perror("Installing handler failed");
                return 1;
        }

        if(sigaction(SIGTSTP, &act, NULL)< 0)
        {
                perror("Installing handler failed");
                return 1;
        }
        return initialize_shell();
}