shell.c

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <pwd.h>
#include <stdbool.h>
#include <sys/wait.h>
#include <signal.h>

#define COMMANDS_NUMBER 4
#define BUILTIN_COMMANDS_NUMBER 3
#define MAX_BUFF 1024 //for pipeline

char *commands[] = {"ls", "hexdump", "cp", "cat"};

//----Built-in functions----
int cd(char *path[]); //change directory
int clear(char *path[]); //clears the CLI, even if it doesnt need any arg still it accepts *path[] to be listed in builtin_f_ptr[]
int whoami(char *path[]);

char *builtincomm[] = {"cd", "clear", "whoami"};
int (*builtin_f_ptr[])(char *args[]) = {cd, clear, whoami};
//--------------------------
//-----Signals Handling-----

void signal_handler(int sigint);
char n_currentdir[100]; //need this to print path after a signal handling (look in signal_handler function)
char n_currentuser[100]; //same as above

//--------------------------
// ---Shell functions---
int command_exec(char *currentuser, char *args[], char *env[]);
bool command_search(char *args[]);
int builtin_command_search(char *args[]);


int main() {

//  ------set env variable------
    char *env[]= {"PATH=commands/", NULL};
// -----------------------------
//  ---Get the user information---
    struct passwd *usr;
    unsigned int uid;
    uid = geteuid();
    usr = getpwuid(uid);

    char currentdir[100];
    char currentuser[100];
    strcpy(currentdir, usr->pw_dir);
    strcpy(currentuser, usr->pw_name);

//  ---signals handling---
    struct sigaction sa;
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGQUIT, &sa, NULL);

    strcpy(n_currentdir, currentdir);
    strcpy(n_currentuser, currentuser);

// -----------------------------
//           ---CLI---
// -----------------------------
    shell: //yeah, i use goto in 2026
    while(true) {
        char command[1024];
        char *args[100];
        printf("%s[%s]>", currentuser, currentdir);
        if (fgets(command, sizeof(command), stdin) != NULL && command[0] != '\n') {
            command[strcspn(command, "\n")] = 0; //cut the final "enter" key

            //now the program has to cut the command in a list of token + pipe discovery
            char *token = strtok(command, " ");
            int i_token = 0;
            int pipe_index = -1;
            int redirection_index = -1;
            while ((token != NULL)) {
                args[i_token] = token;
                if(!strcmp(token, "|")) pipe_index = i_token;
                if(!strcmp(token, ">")) redirection_index = i_token;
                i_token++;
                token = strtok(NULL, " ");
            }
            args[i_token] = NULL; //closing the list

            //---first checks if the command is not NULL or is exit
            if (args[0] == NULL) goto shell;
            if (strcmp("exit", args[0]) == 0) {
                exit(0);
            }

            //-------------------------
            //------PIPE HANDLING------
            //-------------------------

            if (pipe_index > 0) {
                char **command_1 = args;
                char **command_2 = &args[pipe_index + 1];
                command_1[pipe_index] = NULL;

                int fdpipe[2];
                if (pipe(fdpipe) == -1) {
                    perror("Failed to pipe");
                    goto shell;
                }

                pid_t pipe_in = fork();
                switch(pipe_in) {
                    case -1: {
                        perror("Execution failed, not enough memory");
                        break;
                    }
                    case 0: {
                        dup2(fdpipe[1], STDOUT_FILENO); //send the output of command_1 to fdpipe[1]
                        close(fdpipe[1]);
                        close(fdpipe[0]);

                        //Signals handling
                        struct sigaction son_sa;
                        son_sa.sa_handler = SIG_DFL;
                        sigemptyset(&son_sa.sa_mask);
                        son_sa.sa_flags = 0;
                        sigaction(SIGINT, &son_sa, NULL);
                        sigaction(SIGQUIT, &son_sa, NULL);

                        if(builtin_command_search(command_1) != -1) {
                            builtin_f_ptr[builtin_command_search(command_1)](command_1);
                        }

                        else if(command_search(command_1)) {
                            command_exec(currentuser, command_1, env);
                        }
                        exit(1);
                        break;
                    }
                }
                pid_t pipe_out = fork();
                switch(pipe_out) {
                    case -1: {
                        perror("Execution failed, not enough memory");
                        break;
                    }
                    case 0: {
                        dup2(fdpipe[1], STDIN_FILENO); //send the output of command_1 to fdpipe[1]
                        close(fdpipe[1]);
                        close(fdpipe[0]);

                        //Signals handling
                        struct sigaction son_sa;
                        son_sa.sa_handler = SIG_DFL;
                        sigemptyset(&son_sa.sa_mask);
                        son_sa.sa_flags = 0;
                        sigaction(SIGINT, &son_sa, NULL);
                        sigaction(SIGQUIT, &son_sa, NULL);

                        if(builtin_command_search(command_2) != -1) {
                            builtin_f_ptr[builtin_command_search(command_2)](command_2);
                        }

                        else if(command_search(command_2)) {
                            command_exec(currentuser, command_2, env);
                        }
                        exit(1);
                        break;
                    }
                }
                close(fdpipe[0]);
                close(fdpipe[1]);

                waitpid(pipe_in, NULL, 0);
                waitpid(pipe_out, NULL, 0);

                goto shell;
            }

            //----------------------------------
            //-------REDIRECTION HANDLING-------
            //----------------------------------

            if (redirection_index > 0) {
                char **comm = args;
                comm[redirection_index] = NULL;

                char *redirection_file = args[redirection_index+1];

                int fd = open(redirection_file, O_WRONLY | O_CREAT | O_TRUNC, 0664);
                if (fd == -1) {
                    perror("Error");
                    goto shell;
                }

                pid_t pid = fork();
                switch (pid) {
                    case -1: {
                        perror("Execution failed, not enough memory");
                    }
                    case 0: {
                        dup2(fd, STDOUT_FILENO);
                        close(fd);

                        //Signals handling
                        struct sigaction son_sa;
                        son_sa.sa_handler = SIG_DFL;
                        sigemptyset(&son_sa.sa_mask);
                        son_sa.sa_flags = 0;
                        sigaction(SIGINT, &son_sa, NULL);
                        sigaction(SIGQUIT, &son_sa, NULL);

                        if(builtin_command_search(comm) != -1) {
                            builtin_f_ptr[builtin_command_search(comm)](comm);
                        }

                        else if(command_search(comm)) {
                            command_exec(currentuser, comm, env);
                        }

                        else {
                            printf("Command not found");
                        }
                        exit(1);
                        break;
                    }
                }
                close(fd);
                waitpid(pid, NULL, 0);
                goto shell;
            }


            //---------NORMAL EXECUTION---------
            //---COMMAND SEARH AND EXECUTION----


            //---checks if the command is builtin
            int builtin_comm_index = builtin_command_search(args);
            if (builtin_comm_index > -1) {
                builtin_f_ptr[builtin_comm_index](args);
                getcwd(currentdir, sizeof(currentdir)); //refresh dir

                strcpy(n_currentdir, currentdir); //refresh global dir and user values for signal handling
                strcpy(n_currentuser, currentuser);

                goto shell; //no need to enter the following loop
            }

            //in the end, check for command in args
            if (command_search(args)) { //commad_search(args) returns true if found
                pid_t pid = fork();
                if (pid < 0) {
                    perror("Execution failed, not enough memory");
                }
                else if (pid == 0) {

                    //Signals handling
                    struct sigaction son_sa;
                    son_sa.sa_handler = SIG_DFL;
                    sigemptyset(&son_sa.sa_mask);
                    son_sa.sa_flags = 0;
                    sigaction(SIGINT, &son_sa, NULL);
                    sigaction(SIGQUIT, &son_sa, NULL);

                    command_exec(currentuser, args, env);
                    exit(1);
                }
                else {
                    int status;
                    wait(&status);
                }
            }
        }
        if (!command_search(args)) {
            puts("Command not found");
        }
    }
    return 0;
}



//-----------------------------------
// ------------FUNCTIONS-------------
// ----------------------------------


//----Built-in functions----

int cd(char *path[]) {
    struct passwd *usr;
    unsigned int uid;
    uid = geteuid();
    usr = getpwuid(uid);
    if (path[1] == NULL) {
        chdir(usr->pw_dir);
        return 0;
    }
    if (chdir(path[1]) == -1) {
        printf("Can't find directory %s\n", path[1]);
    }
    return 0;
}

int clear(char *path[]) {
    printf("\033[H\033[2J\033[3J"); //ANSI escape sequence
    fflush(stdout);
    return 0;
}

int whoami(char *path[]){
    struct passwd *usr;
    unsigned int uid;
    uid = geteuid();
    usr = getpwuid(uid);
    puts(usr->pw_name);
    return 0;
}


//----Signal Handler----

void signal_handler(int sigint) {
    switch (sigint) {
        case SIGINT: printf("\n%s[%s]>", n_currentuser, n_currentdir); break;
        case SIGQUIT: printf("\n%s[%s]>", n_currentuser, n_currentdir); break;
        default: break;
    }
    fflush(stdout);
}

// Shell functions

int command_exec(char *currentuser, char *args[], char *env[]) {
    char commpath[256];
    snprintf(commpath, sizeof(commpath), "/home/%s/Desktop/programmiC/shell/commands/%s", currentuser, args[0]);
    execve(commpath, args, env);
    perror("Error: ");
    return 0;
}

bool command_search(char *args[]) {
    for (ssize_t i = 0; i<COMMANDS_NUMBER; i++) {
        if (strcmp(commands[i], args[0]) == 0) return true;
    }
    return false;
}

int builtin_command_search(char *args[]) {
    for (int i = 0; i < BUILTIN_COMMANDS_NUMBER; i++) {
        if (strcmp(args[0], builtincomm[i]) == 0) {
            return i;
        }
    }
    return -1;
}