shell.c

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

// Header files for commands defined manually 
#include "gls.h"
#include "gcd.h"
#include "ggrep.h"
#include "gcat.h"
#include "gmv.h"
#include "gpwd.h"
#include "gcp.h"
#include "gmkdir.h"

// sentence_size == size of the command one user can enter (Global)
// separator is used in string tokienization (Global)
#define sentence_size 1024
#define separator " \t\r\n\a&"

// Functions defined for user commands
int gcd(char **args);
int help(char **args);
int gexit(char **args);
int ggrep(char **args);
int gls(char **args);
int gcat(char **args);
int gmv(char **args);
int gpwd(char **args);
int grm(char **args);
int gcp(char **args);
int gmkdir(char **args);
 
// Information helper function for user using this Terminal accessible using help command
int help(char **args)
{
  int i;
  system("clear");
  printf("\nThis is a Custom Shell written in C programming Language\n\n");
  printf("Custom Commands added - gcat, gcd, ggrep, gls, gmv, gcp, gpwd, gmkdir.\n\n");
  printf("All Custom Commands are simple ones ex. gcat is a simpler version of cat and lly for other cmds.\n\n");
  printf("\n--------------------Have Fun--------------------\n\n");
  return 1;
}
// exit command used for leaving the terminal process
int gexit(char **args)
{
  printf("Exiting.........\n");
  exit(EXIT_SUCCESS);
  return 0;
} 
/* Arguments list which are defined manually(means no builtins)..... (Global)

All commands working is the simple case working of different terminal commands 
For ex. ggrep == grep, gcd == cd, gls == ls, gmv == mv...etc
*/

char *myArgs_list[] = {
  "help",
  "gexit",
  "gmkdir",
  "gcd",
  "gls",
  "gmv",
  "ggrep",
  "gcat",
  "gcp",
  "gpwd"
};
// Manually defined arguments list length (Global) 
int myArgs_list_size = sizeof(myArgs_list)/sizeof(char*);

// function to tokenize or split the sentence into its words or equivalently command into arguments.
// Parameter sentence is accepted from the user using fgets() in main().
char** split_sentence(char *sentence){
  char **args_list = malloc(sentence_size*sizeof(char*)); // Defining argument character array with column 1024 with each box of bits equal to bits of char
  char *token; // word or token extracted from the sentence or command
  int index=0; // index for storing the tokens in args_list

  if(!args_list){ // Failure in the Memory allocation of args_list
    fprintf(stderr,"Memory allocation Failed\n");
    exit(EXIT_FAILURE); // exit(EXIT_FAILURE) ensures the termination of the process 
  }
  token= strtok(sentence,separator); // strtok() accepts the string with the delimiters on basis of which the command to be splitted into words
  // strtok() returns a pointer to the next token and NULL if no token exsist. 
  while(token!=NULL){ // Checking if the tokens are finished or not in the string
    args_list[index] = token; // stroing the tokens in the args_list
    index++; // incrementing index to store unique tokens in unique places in the args_list
    token = strtok(NULL,separator); // Take pointer to the next token
  }
  args_list[index]=NULL; // Stroing NULL at the last
  return args_list; // Complete args_list with all arguments
}


int builtin(char **args) // Builtin function to run commands which are not defined by the user 
{
  int rc,wait; //rc flag to ensure the creation of child process, wait flag for storing the successful run of child as child pid or an error as -1
  int status; // ensure that the command is ran successfully with no error and carry on the loop in main() using this status
  rc=fork(); // creating Parent and Child Processes
  if(rc<0){  // child not created
      fprintf(stderr,"FORK NOT WORKING\n"); 
  }
  else if(rc==0){ // Child process
  /*
execvp() -- second argument is an array of null-terminated strings that represent
 the appropriate arguments to the file as specified in the man page.
   executing the builtin command args[0] represent the file you want to execute
  */
      if(execvp(args[0],args)==-1){
          fprintf(stderr,"Enter the correct command\n");
      }
  }else{
      do{ 
          wait=waitpid(rc, &status, WUNTRACED); // wait() command waits for the process to change the state
      }while(!WIFEXITED(status) && !WIFSIGNALED(status));
    // WIFEXITED returns true if the child terminated normally.
    // WIFSIGNALED returns true if the child process was terminated by a signal.
    // WUNTRACED also  return if a child has stopped.
  }
  return 1; // Indicates the successful running of the command and allowing loop in main to carry further commands
}
// Function which either run defined commands or the builtin command
// Parameter accepted is args which came from the splitting function split_sentence()

int redirect(char **args){
    if(args[0] == NULL){
        return 1;   
    } // If no command is entered and user press simply enter then status == 1 retured, to continue the loop in main()

    for(int i=0;i<myArgs_list_size;i++) 
    {
      /*Checking if the entered command argument matches with the argument defined
        If yes, then run the user defined command defined in myArgsList[]
        If not, then run builtin binary commands defined.
      */
        if(strcmp(args[0],myArgs_list[i])==0){ //Commands comparison using stringCompare strcmp()
            switch (i)
            {
            case 0:
                return help(args);
                
            case 1:
                return gexit(args);
                
            case 2:
                return gmkdir(args);
                
            case 3:
                return gcd(args);
                
            case 4:
                return gls(args);
                
            case 5:
                return gmv(args);
                
            case 6:
                return ggrep(args);
                
            case 7:
                return gcat(args);
            case 8:
                return gcp(args);
            case 9:
                return gpwd(args);   
            default:
                break;
            }
        }
    }
    return builtin(args); // If no command matches then run the builtin command
    
}
int check_chracter(char *input){
    char *output = NULL;
    output = strrchr(input, '&');

    if(output != NULL){
        return 1;
    }
    return 0;
}


int main(int argc, char const *argv[])
{
  /*Loop which continues and waiting for 
  command to enter and can be 
  terminated by using exit command (defined above) 
  or ctrl+C keyboard intterupt
  */
  system("clear"); // Used to clear the terminal screen
  printf("--Welcome to Lovepreet's Shell--\n\n");

  char  **args; // Used to store the arguments splitted from the command entered in the terminal
  int n_args; // Number of arguments or words splitted
  int status; // Status of command whether ran correct or not
  char* sentence = malloc(sentence_size); // stores the input from the user entered in the terminal

  do{
    char dir[500]; // Character array defined to store the current directory
    ssize_t size = 500; // size command for the getcwd()
    getcwd(dir, size); // Storing the current working directory into dir char array of size 500
    printf("%s > ", dir); // Print the current directory on the terminal
    
    fgets(sentence,sentence_size,stdin);// Read the input from the terminal entered by the user
    int flag = check_chracter(sentence); // Check if & is present or not to run commands in background
    // printf("Flag : %d\n", flag);
    if(flag){ 
      int rc = fork();
      if(rc < 0){ // Child creation Failed
        perror("Fork Failed\n"); 
      }
      else if(rc == 0){ // Child process
        args = split_sentence(sentence); // splitting the sentence entered by the user.
        n_args = sizeof(args)/sizeof(char); // Number of tokens splitted from the whole inputted command
        status = redirect(args); // redirect to a function which will run either a command defined or a builtin binary command
        free(args);
      }
      else{
        status = 1;
        continue;
      }
    }else{ // Process running not in background
        args = split_sentence(sentence); // splitting the sentence entered by the user.
        n_args = sizeof(args)/sizeof(char); // Number of tokens splitted from the whole inputted command
        status= redirect(args); // redirect to a function which will run either a command defined or a builtin binary command

        free(args); // Memory free from the storage of the earlier entered arguments
    }
        
    }while(status); // Make the loop running until error doesn't occur (fork failed or memory allocation error) or process not interrupted
 
  return 0;
}