#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>

#define INPUT_SIZE 1024
#define R_OUT '>'
#define R_IN '<'
#define PIPE '|'
#define SPACE ' '
#define TRUE 1
#define FALSE 0

pid_t childPid;

/**
* Control structure for a string tokenizer. Maintains the
* tokenizer's state.
*/
typedef struct tokenizer {
char *curr; /* the string to parse */
char *next; /* position in string */
} TOKENIZER;

TOKENIZER init_tokenizer(char *string);

char * next_letter(char * ch);
char * next_space(char * ch);
void move_next_token_pointer_forward(TOKENIZER *tokenizer);
char *get_next_token(TOKENIZER *tokenizer);

/***************************************************************************/

void sigintHandler(int sig);

void registerSignalHandlers();

void killChildProcess();

/***************************************************************************/

void writeToStdout(char *text);

int get_index_of_null_letter(char * string);
void add_front_space_to_index_in_string(char * string, int index);
void add_back_space_to_index_in_string(char * string, int index);

void add_space_to_string(char * string);

int validateInputOutputRedirect(char * arr[]);

int array_length(char * arr[]);
int get_index_of_letter(char * arr[], char letter);

void shift_left(char * arr[], int from, int length);
void redirect_stdout(char * arr[]);

void redirect_stdin(char * arr[]);

void copy_string(char * old, char * new);
void child_process(char * string);

int string_length(char * string);
int right_trim(char * string);
char * left_trim(char * string);
void process(char * string);

/**
* Main program execution
*/
int main(int argc, char *argv[]) {

char string[INPUT_SIZE] = "";

int br;
registerSignalHandlers();

string[INPUT_SIZE - 1] = '\0'; /* ensure that string is always null-terminated */
writeToStdout("penn-sh> ");
while ((br = read(STDIN_FILENO, string, INPUT_SIZE - 1)) > 0) {
   if (br <= 1){
         writeToStdout("penn-sh> ");
         continue;
   }

   string[br - 1] = '\0'; /* remove trailing \n */
   process(string);
   writeToStdout("penn-sh> ");
}

//printf("\nBye!\n");
return 0; /* all's well that end's well */
}

void process(char * string) {
int status;
string = left_trim(string);

if (right_trim(string) < 0) {
   return;
}

add_space_to_string(string);
//writeToStdout(string);
childPid = fork();

if (childPid < 0) {
   perror("invalid: fork");
   return;
}

if (childPid == 0) {
   child_process(string);
} else {
   do {
         if (wait(&status) == -1) {
            perror("invalid: Error in child process termination");
            exit(EXIT_FAILURE);
         }
   } while (!WIFEXITED(status) && !WIFSIGNALED(status));
   childPid = 0;
}
}

char * left_trim(char * string){
if (string == NULL) {
   return NULL;
}
char * tmp = string;
while (*tmp != '\0' && isspace(*tmp)) {
   tmp +=1;
}
return tmp;
}

int right_trim(char * string) {
if (string == NULL) {
   return -1;
}
int last_index = string_length(string) - 1;
while (last_index >= 0 && isspace(string[last_index])) {
   string[last_index] = '\0';
   last_index--;
}
return last_index;
}

/**
* get length of the string
* @param string
* @return
*/
int string_length(char * string) {
return get_index_of_null_letter(string);
}

/**
*
* @param string
*/
void child_process(char * string) {
TOKENIZER tokenizer;
char new_string[INPUT_SIZE];
new_string[INPUT_SIZE - 1] = '\0';
copy_string(string, new_string);
tokenizer = init_tokenizer(new_string);
if (tokenizer.next == NULL || *(tokenizer.next) == '\0') {
   return;
}
char * arr[512];
int index = 0;
while (get_next_token(&tokenizer) != NULL) {
   arr[index] = tokenizer.curr;
   index++;
}
arr[index] = NULL;

if (validateInputOutputRedirect(arr) == FALSE) {
   exit(EXIT_FAILURE);
}
redirect_stdout(arr);
redirect_stdin(arr);

char * command = arr[0];

if (execvp(command, arr) == -1) {
   perror("Invalid");
   exit(EXIT_FAILURE);
}
}

/**
* copy the string
* assume that there is enough memory space
* @param old
* @param new
*/

Design a program that will be used at a local night club. Users of...