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>   



/*
 * 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() { // Main loop handling user input and command execution
    char input_buffer[SH_CMD_MAX];
    cmd_buff_t cmd;
    
    while (1) { // Infinite loop to continuously prompt user for input
        printf("%s", SH_PROMPT); // Display shell prompt
        if (fgets(input_buffer, SH_CMD_MAX, stdin) == NULL) { // Read user input
            printf("\n");
            break;
        }
        
        // Remove trailing newline
        input_buffer[strcspn(input_buffer, "\n")] = '\0'; // Remove newline character
        
        // Skip empty input
        if (strlen(input_buffer) == 0) { // Skip empty input
            continue;
        }
        
        // Allocate command buffer
        if (alloc_cmd_buff(&cmd) != OK) {
            printf("Error allocating command buffer.\n");
            continue;
        }
        
        // Build command buffer
        if (build_cmd_buff(input_buffer, &cmd) != OK) {
            printf("Error parsing command.\n");
            free_cmd_buff(&cmd);
            continue;
        }
        
        // Handle built-in commands
        Built_In_Cmds built_in = match_command(cmd.argv[0]); // Identify built-in commands
        if (built_in != BI_NOT_BI) {
            exec_built_in_cmd(&cmd);
            free_cmd_buff(&cmd);
            continue;
        }
        
        // Execute external command
        exec_cmd(&cmd);
        
        // Free command buffer
        free_cmd_buff(&cmd);
    }
    return OK;
}

int exec_cmd(cmd_buff_t *cmd) {
    pid_t pid = fork(); // Create a child process
    if (pid < 0) {
        perror("fork failed");
        return ERR_EXEC_CMD;
    }
    
    if (pid == 0) { // Child process executes command
        // Replace current process image with the new command using execvp()
        // execvp() looks for the command in PATH and replaces the process if found
        execvp(cmd->argv[0], cmd->argv);
        perror("execvp failed");
        exit(ERR_EXEC_CMD);
    } else { // Parent process waits for child process to complete
        int status;
        waitpid(pid, &status, 0);
        if (WIFEXITED(status)) { // Check if process exited normally
            int exit_status = WEXITSTATUS(status);
           // printf("%d\n", exit_status);
           if (exit_status != 0) {
            return ERR_EXEC_CMD; 
           }
          // continue;
        }
    }
    return OK;
}

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 BI_RC;
    return BI_NOT_BI;
}


/*
Built_In_Cmds exec_built_in_cmd(cmd_buff_t *cmd) {

    const char *target_dir;
    // Handle 'exit' command - Terminates the shell
    if (strcmp(cmd->argv[0], "exit") == 0) {
        free_cmd_buff(cmd);
        exit(0);
    }
    
    // Handle 'cd' command - Changes the working directory
    if (strcmp(cmd->argv[0], "cd") == 0) {
       // const char *target_dir;

        
        //if (cmd->argc > 1) {
          //  if (access(cmd->argv[1], F_OK) == -1) {
              //  printf("cd failed: No such directory\n");
           // } else if (access(cmd->argv[1], R_OK | X_OK) == -1) {
               // printf("cd failed: Permission denied\n");
          //  } else if (chdir(cmd->argv[1]) != 0) {
              //  printf("cd failed: Unknown error\n");
           // }
      //  } else {
       //     chdir(getenv("/tmp")); // Change to home directory if no argument
     //   }
    //    return BI_EXECUTED;
   // }
    
        if (cmd->argc > 1) {
            target_dir = cmd->argv[1];  // Use provided directory
        } else {
            target_dir = "/temp";  // Default to /tmp
        }

        return BI_EXECUTED;
    }
        

        // Check if directory exists
        struct stat st;
        if (stat(target_dir, &st) == -1) {
        // Directory does not exist, attempt to create it
            if (mkdir(target_dir, 0777) != 0) {
                perror("mkdir failed");  // Print error message if mkdir fails
                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); // Always print new working directory
            }
        }
        
    
        return BI_EXECUTED;
    


    // Handle 'rc' command - Prints last error code
    if (strcmp(cmd->argv[0], "rc") == 0) {
        printf("%d\n", errno);
        return BI_EXECUTED;
    }
    return BI_NOT_BI;
}
*/

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 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 > 2) {  // Too many arguments for cd
            fprintf(stderr, "error: cd command accepts at most 1 argument\n");
            return ERR_CMD_ARGS_BAD;
        }

        // Use provided directory or default to `/tmp`
        strncpy(target_dir, (cmd->argc > 1) ? cmd->argv[1] : "/tmp", PATH_MAX);
        //target_dir[PATH_MAX - 1] = '\0';  // Ensure null-termination

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

        // Ensure the directory is accessible
        if (access(target_dir, R_OK | X_OK) != 0) {
            perror("cd failed: Permission denied");
            return BI_EXECUTED;
        }

        //  Change directory and print current path
        if (chdir(target_dir) == 0) {
            char cwd[PATH_MAX];
            if (getcwd(cwd, sizeof(cwd)) != NULL) {
                printf("%s\n", cwd);
            } else {
                perror("getcwd failed");
            }
        } else {
            perror("cd failed");
        }

        return BI_EXECUTED;
    }

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

    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;
}