dshlib.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include "dshlib.h"
#include <errno.h>
#include <limits.h>
#include <sys/types.h>  
#include <sys/stat.h>   




/**** 
 **** FOR REMOTE SHELL USE YOUR SOLUTION FROM SHELL PART 3 HERE
 **** THE MAIN FUNCTION CALLS THIS ONE AS ITS ENTRY POINT TO
 **** EXECUTE THE SHELL LOCALLY
 ****
 */

/*
 * Implement your exec_local_cmd_loop function by building a loop that prompts the 
 * user for input.  Use the SH_PROMPT constant from dshlib.h and then
 * use fgets to accept user input.
 * 
 *      while(1){
 *        printf("%s", SH_PROMPT);
 *        if (fgets(cmd_buff, ARG_MAX, stdin) == NULL){
 *           printf("\n");
 *           break;
 *        }
 *        //remove the trailing \n from cmd_buff
 *        cmd_buff[strcspn(cmd_buff,"\n")] = '\0';
 * 
 *        //IMPLEMENT THE REST OF THE REQUIREMENTS
 *      }
 * 
 *   Also, use the constants in the dshlib.h in this code.  
 *      SH_CMD_MAX              maximum buffer size for user input
 *      EXIT_CMD                constant that terminates the dsh program
 *      SH_PROMPT               the shell prompt
 *      OK                      the command was parsed properly
 *      WARN_NO_CMDS            the user command was empty
 *      ERR_TOO_MANY_COMMANDS   too many pipes used
 *      ERR_MEMORY              dynamic memory management failure
 * 
 *   errors returned
 *      OK                     No error
 *      ERR_MEMORY             Dynamic memory management failure
 *      WARN_NO_CMDS           No commands parsed
 *      ERR_TOO_MANY_COMMANDS  too many pipes used
 *   
 *   console messages
 *      CMD_WARN_NO_CMD        print on WARN_NO_CMDS
 *      CMD_ERR_PIPE_LIMIT     print on ERR_TOO_MANY_COMMANDS
 *      CMD_ERR_EXECUTE        print on execution failure of external command
 * 
 *  Standard Library Functions You Might Want To Consider Using (assignment 1+)
 *      malloc(), free(), strlen(), fgets(), strcspn(), printf()
 * 
 *  Standard Library Functions You Might Want To Consider Using (assignment 2+)
 *      fork(), execvp(), exit(), chdir()
 */

 int exec_local_cmd_loop() {
    char input_buffer[SH_CMD_MAX];
    command_list_t clist;

    while (1) {
        printf("%s", SH_PROMPT);
        if (fgets(input_buffer, SH_CMD_MAX, stdin) == NULL) {
            printf("\n");
            break;
        }
        input_buffer[strcspn(input_buffer, "\n")] = '\0';
        if (strlen(input_buffer) == 0) continue;

        // Parsing command list
        int rc = build_cmd_list(input_buffer, &clist);
        if (rc != OK) {
            if (rc == WARN_NO_CMDS) printf(CMD_WARN_NO_CMD);
            else if (rc == ERR_TOO_MANY_COMMANDS) printf(CMD_ERR_PIPE_LIMIT, CMD_MAX);
            continue;
        }

        // Check built-in commands
        if (clist.num > 1) {
            for (int i = 0; i < clist.num; i++) {
                Built_In_Cmds bi = match_command(clist.commands[i].argv[0]);
                if (bi != BI_NOT_BI) {
                    fprintf(stderr, "error: built-in command in pipeline\n");
                    rc = ERR_CMD_ARGS_BAD;
                    break;
                }
            }
            if (rc != OK) {
                free_cmd_list(&clist);
                continue;
            }
        } else {
            cmd_buff_t *cmd = &clist.commands[0];
            Built_In_Cmds bi = match_command(cmd->argv[0]);
            if (bi != BI_NOT_BI) {
                exec_built_in_cmd(cmd);
                free_cmd_list(&clist);
                continue;
            }
        }

        // Execution pipeline
        execute_pipeline(&clist);
        free_cmd_list(&clist);
    }
    return OK;
}



/**
 * @brief Executes a single command, handling output redirection.
 */
int exec_cmd(cmd_buff_t *cmd) {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork failed");
        return ERR_EXEC_CMD;
    }

    if (pid == 0) {  // Child Process
        int fd = -1;
        char *output_file = NULL;
        int append_mode = 0;
        char *argv_clean[CMD_ARGV_MAX];
        int i, j = 0;

        // Look for `>` or `>>` in the command arguments
        for (i = 0; i < cmd->argc; i++) {
            if (strcmp(cmd->argv[i], ">") == 0 || strcmp(cmd->argv[i], ">>") == 0) {
                if (i + 1 >= cmd->argc) {
                    fprintf(stderr, "error: no output file specified\n");
                    exit(ERR_EXEC_CMD);
                }
                output_file = cmd->argv[i + 1];
                append_mode = (strcmp(cmd->argv[i], ">>") == 0);
                i++;  // Skip the filename in arguments
            } else {
                argv_clean[j++] = cmd->argv[i];  // Copy valid arguments
            }
        }
        argv_clean[j] = NULL;  // Null-terminate the cleaned-up argument list

        // Redirect output to a file if needed
        if (output_file) {
            fd = open(output_file, O_WRONLY | O_CREAT | (append_mode ? O_APPEND : O_TRUNC), 0644);
            if (fd < 0) {
                perror("Failed to open output file");
                exit(ERR_EXEC_CMD);
            }
            dup2(fd, STDOUT_FILENO);
            close(fd);
        }

        // Execute the actual command
        execvp(argv_clean[0], argv_clean);
        perror("execvp failed");
        exit(ERR_EXEC_CMD);
    } else {
        waitpid(pid, NULL, 0);
        return OK;
    }
}





// Processing pipeline execution
int execute_pipeline(command_list_t *clist) {
    int num_cmds = clist->num;
    int prev_pipe = -1;
    int fd[2];
    pid_t pids[num_cmds];

    for (int i = 0; i < num_cmds; i++) {
        if (i < num_cmds - 1 && pipe(fd) < 0) {
            perror("pipe");
            return ERR_EXEC_CMD;
        }

        pids[i] = fork();
        if (pids[i] < 0) {
            perror("fork");
            return ERR_EXEC_CMD;
        }

        if (pids[i] == 0) { // Child
            if (i > 0) {
                dup2(prev_pipe, STDIN_FILENO);
                close(prev_pipe);
            }
            if (i < num_cmds - 1) {
                dup2(fd[1], STDOUT_FILENO);
                close(fd[1]);
            }
            // Close all pipe ends
            if (i > 0) close(prev_pipe);
            if (i < num_cmds-1) close(fd[0]);

            execvp(clist->commands[i].argv[0], clist->commands[i].argv);
            perror("execvp failed");
            exit(ERR_EXEC_CMD);
        } else { // Parent
            if (i > 0) close(prev_pipe);
            if (i < num_cmds - 1) {
                prev_pipe = fd[0];
                close(fd[1]);
            }
        }
    }

    // Wait for all children
    for (int i = 0; i < num_cmds; i++) {
        waitpid(pids[i], NULL, 0);
    }
    return OK;
}


Built_In_Cmds exec_built_in_cmd(cmd_buff_t *cmd) {
    if (strcmp(cmd->argv[0], "exit") == 0) {
        free_cmd_buff(cmd);
        exit(0);
    }

    if (strcmp(cmd->argv[0], "cd") == 0) {
        char target_dir[PATH_MAX];

        if (cmd->argc > 1) {
            strncpy(target_dir, cmd->argv[1], PATH_MAX);
        } if (cmd->argc > 2) { // Too many arguments for cd
            fprintf(stderr, "error: cd command accepts at most 1 argument\n");
            return ERR_CMD_ARGS_BAD;
        }
           // strncpy(target_dir, "/tmp", PATH_MAX); // Default to /tmp
        

        // Ensure string is null-terminated
        target_dir[PATH_MAX - 1] = '\0';

        // Check if directory exists
        struct stat st;
        if (stat(target_dir, &st) == -1) {
            if (mkdir(target_dir, 0777) != 0) {
                //perror("mkdir failed");
                return BI_EXECUTED;
            }
        }

        // Check permissions before `chdir()`
        if (access(target_dir, R_OK | X_OK) != 0) {
            perror("cd failed");
            return BI_EXECUTED;
        }

        // Attempt to change directory
        if (chdir(target_dir) != 0) {
            perror("cd failed");
        } else {
            char cwd[PATH_MAX];
            if (getcwd(cwd, sizeof(cwd)) != NULL) {
                //printf("%s\n", cwd);  // Print working directory only once
            } else {
                perror("getcwd failed");
            }
        }

        return BI_EXECUTED;
    }

    if (strcmp(cmd->argv[0], "rc") == 0) {
        printf("%d\n", errno);
        return BI_EXECUTED;
    }

    return BI_NOT_BI;
}

Built_In_Cmds match_command(const char *input) {
    if (strcmp(input, "exit") == 0) return BI_CMD_EXIT;
    if (strcmp(input, "cd") == 0) return BI_CMD_CD;
    if (strcmp(input, "rc") == 0) return -1;
    return BI_NOT_BI;
}



int alloc_cmd_buff(cmd_buff_t *cmd_buff) {
    cmd_buff->_cmd_buffer = (char *)malloc(SH_CMD_MAX);
    if (!cmd_buff->_cmd_buffer) return ERR_MEMORY;
    memset(cmd_buff, 0, sizeof(cmd_buff_t));
    return OK;
}

int free_cmd_buff(cmd_buff_t *cmd_buff) {
    if (cmd_buff->_cmd_buffer) {
        free(cmd_buff->_cmd_buffer);
        cmd_buff->_cmd_buffer = NULL;
    }
    return OK;
}

int clear_cmd_buff(cmd_buff_t *cmd_buff) {
    memset(cmd_buff, 0, sizeof(cmd_buff_t));
    return OK;
}

int build_cmd_buff(char *cmd_line, cmd_buff_t *cmd_buff) {
    cmd_buff->argc = 0;
    char *ptr = cmd_line;
    int in_quotes = 0;
    char *token_start = NULL;

    while (*ptr) {
        while (isspace(*ptr) && !in_quotes) ptr++; // Skip spaces outside quotes

        if (*ptr == '"') { // Detect start of quoted string
            in_quotes = !in_quotes;
            ptr++;
            token_start = ptr;
        } else {
            token_start = ptr;
        }

        while (*ptr && (in_quotes || !isspace(*ptr))) { // Capture argument
            if (*ptr == '"') {
                in_quotes = !in_quotes;
                *ptr = '\0';  // Properly terminate quoted string
            }
            ptr++;
        }

        if (*ptr) {
            *ptr = '\0';  // Terminate non-quoted argument
            ptr++;
        }

        cmd_buff->argv[cmd_buff->argc++] = token_start;
        //if (cmd_buff->argc >= CMD_ARGV_MAX - 1) break;
        if (cmd_buff->argc > CMD_ARGV_MAX - 1) {
            fprintf(stderr, "error: too many arguments\n");
            return ERR_CMD_ARGS_BAD;  // Return error -4
        }
    }
    cmd_buff->argv[cmd_buff->argc] = NULL;
    return OK;
}


// Used to split commands by pipeline
int build_cmd_list(char *cmd_line, command_list_t *clist) {
    clist->num = 0;
    char *saveptr;
    char *token = strtok_r(cmd_line, "|", &saveptr);

    while (token != NULL) {
        if (clist->num >= CMD_MAX) {
            fprintf(stderr, CMD_ERR_PIPE_LIMIT, CMD_MAX);
            return ERR_TOO_MANY_COMMANDS;
        }

        // Trim leading/trailing spaces
        while (*token == ' ') token++;
        size_t len = strlen(token);
        while (len > 0 && token[len-1] == ' ') token[--len] = '\0';

        cmd_buff_t *cmd = &clist->commands[clist->num];
        if (alloc_cmd_buff(cmd) != OK) return ERR_MEMORY;

        int rc = build_cmd_buff(token, cmd);
        if (rc != OK) {
            free_cmd_buff(cmd);
            return rc;
        }

        clist->num++;
        token = strtok_r(NULL, "|", &saveptr);
    }

    if (clist->num == 0) {
        printf(CMD_WARN_NO_CMD);
        return WARN_NO_CMDS;
    }
    return OK;
}

// Release command list
int free_cmd_list(command_list_t *clist) {
    for (int i = 0; i < clist->num; i++) {
        free_cmd_buff(&clist->commands[i]);
    }
    clist->num = 0;
    return OK;
}