myshell.c

// Incluimos las cabeceras necesarias que vamos a usar
#define _GNU_SOURCE
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include "parser.h"
#include <signal.h>
#include <bits/waitflags.h>

//-- DEFINICIONES DE DATOS PARA EL CONTROL DE LOS TRABAJOS --//
// La lista de trabajos solo almacena procesos que están en background (RUNNING) o detenidos (STOPPED).
// No se añaden los procesos que terminan normalmente en foreground.
// Enumerado para indicar si un trabajo está corriendo o parado:
typedef enum {RUNNING, STOPPED} job_state;
// Estructura que guarda la info de un trabajo:
typedef struct {
    int job_id; // Identificador del job
    pid_t pid; // PID (único) del proceso principal
    char *cmdline; // Guarda al comando original (ejem. ls -l | wc)
    job_state state; // Estado: RUNNING o STOPPED
} job_t;

job_t job_list[128]; // Lista para guardar hasta 128 trabajos (job_t)
int num_jobs = 0; // Entero que indica cuántos trabajos (job_t) hay en la lista (job_list)
int next_job_id = 1; // Entero que indica el siguiente id de job

// --- A continuación, se definen funciones auxiliares para jobs ---//
// La función find_job_pid busca en jobs_list un pid que coincida con el que se le pasa y devuelve su índice o -1 si no se encuentra:
int find_job_pid(pid_t pid) {
    int i;
    for (i = 0; i < num_jobs; i++) {
        if (job_list[i].pid == pid) {
            return i;
        }
    }
    return -1;
}

// La funcion remove_job elimina de ljob_list el trabajo indicado por el pid:
void remove_job(pid_t pid) {
    int i;
    for (i = 0; i < num_jobs; i++) {
        if (job_list[i].pid == pid) {
            free(job_list[i].cmdline);
            // Mover el último job a esta posición
            job_list[i] = job_list[num_jobs - 1];
            num_jobs--;
            return;
        }
    }
}

// La función sig_handler es un manejador asociado a la señal SIGCHLD. 
// Se envía a un proceso cuando un hijo tiene un cambio de estado.
void sigchld_handler(int sig){
    (void)sig; //ignoramos para que no salga warning. No lo podemos quitar pq es obligatorio el parametro.
    int status; // Para almacenar el estado devuelto por waitpid()
    pid_t pid; // Para almacenar el pid devuelto por waitpid
    int index; // Para guardar el índice de la job_list asociado al pid devuelto.
    // En el siguiente while, el waitpid espera por cualquier hijo (-1). 
    // WNOHANG -> hace que waitpid() no se bloquee si ningún hijo ha cambiado de estado
    // WUNTRACED -> informa cuando un hijo ha sido detenido
    // WCONTINUED -> informa cuando un hijo es reanudado
    while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED | WCONTINUED)) > 0) {
        index = find_job_pid(pid); 
        if (index == -1){ // Si no se ha encontrado por pid, continuamos
            continue;
        }
        // WIFSTOPPED se usa después de llamar a waitpid() para comprobar si un proceso hijo ha sido detenido por una señal
        if (WIFSTOPPED(status)) {
            job_list[index].state = STOPPED; // Actualizamos el estado a STOPPED
        } 
        // WIFEXITED comprueba si un proceso hijo terminó normalmente (llamando a exit(0) o haciendo return)
        // WIFSIGNALED comprueba si un hijo ha terminado porque recibió una señal (murió anormalmente)
        else if (WIFEXITED(status) || WIFSIGNALED(status)) {
            remove_job(pid); // Lo borramos de la lista pq ya no existe
        } 
        // WIFCONTINUED devuelve 1 si el hijo ha sido reanudado (despues de haber estado parado)
        else if (WIFCONTINUED(status)) {
            job_list[index].state = RUNNING; // Actualizamos el estado a RUNNING
        }
    }
}

// La funcion add_job añade un nuevo trabajo a job_list si hay espacio
void add_job(pid_t pid, const char *cmdline, job_state status) {
    if (num_jobs >= 128) {
        fprintf(stderr, "jobs: demasiados jobs\n");
        return;
    }

    // Intentamos duplicar el string
    char *dup_command = strdup(cmdline);
    if (dup_command == NULL){
        perror("Error al duplicar cmdline");
        exit(1);
    }
    job_list[num_jobs].job_id = next_job_id++; // Tras asignar el next_job_id incrementamos dicha variable
    job_list[num_jobs].pid = pid;
    job_list[num_jobs].cmdline = dup_command;
    job_list[num_jobs].state = status;
    num_jobs++;
}

// Funcion para actualizar el estado de un job por pid
void update_job_status(pid_t pid, job_state state) {
    int i;
    for (i = 0; i < num_jobs; i++) {
        if (job_list[i].pid == pid) {
            job_list[i].state = state;
            return;
        }
    }
}

// Funcion para obtener un job parado (STOPPED) por ID, o el último parado si id == -1. Si no se encuentra devuelve NULL
job_t *get_stopped_job(int id) {
    int i;
    if (id > 0) {
        for (i = 0; i < num_jobs; i++) {
            if (job_list[i].job_id == id && job_list[i].state == STOPPED) {
                return &job_list[i];
            }
        }
        return NULL;
    } else {
        // Último parado
        for (i = num_jobs - 1; i >= 0; i--) {
            if (job_list[i].state == STOPPED){
                return &job_list[i];
            }
        }
        return NULL;
    }
}


// Función main:
int main(void) {

    //Requerimiento de estilo: Variables justo despues de "main(...){"
    char buf[1024]; // Para almacenar lo que lea fgets
    tline *line; // Para almacenar lo que devuelva tokenize()
    int i, j, k; // Contadores para bucles
    
    //Variables de la logica de pipes/hijos
    int num_pipes;
    int (*pipes)[2];
    pid_t *pids_hijos;
    
    //Variables de foreground
    int status_fg;
    
    //Variables CD
    const char *home_dir = getenv("HOME");
    char cwd[1024];
    
    //Variables UMASK
    int argc;     
    char *arg;   
    char *endptr;
    long new_mask; // Variable auxiliar para strtol
    
    //Variables BG
    int id_job_a_buscar;
    job_t *job;
    
    //variables del hijo
    pid_t pid;
    sigset_t mask_all, prev_mask;

    //Variables redirecciones
    int fd_in, fd_out, fd_err;

    
    // Señales
    // El padre (minishell) debe ignorar señales SIGINT y SIGSTP
    // SIG_IGN es un handler que ignora la señal que se le pasa
    signal(SIGINT, SIG_IGN); // Indicamos que ignore la señal SIGINT (Ctrl + C)
    signal(SIGTSTP, SIG_IGN); // Indicamos que ignore la señal SIGSTP (Ctrl + Z)
    signal(SIGCHLD, sigchld_handler); // Asociamos la funcion sigchld_handler a la señal SIGCHLD

    // Se ejecuta un bucle infinito (hasta que se decida salir)
    while (1) {

        printf("msh> "); //Imprimimos el prompt
        
        while (fgets(buf, 1024, stdin) == NULL) {
            // Si fgets falla por una señal (EINTR), limpiamos error y seguimos
            if (ferror(stdin) && errno == EINTR) {
                clearerr(stdin);
                continue; 
            }
            // Si es fin de archivo real (Ctrl+D), salimos
            break;
        }

        line = tokenize(buf); //Separamos los comandos
        num_pipes = line->ncommands - 1; // Calculamos cuántos pipes hacen falta, que será el num de comandos menos uno

        // Si la línea está vacía o hubo error, volvemos a empezar mostrando el prompt
        // line->ncommands == 0: accedemos al campo ncommands del struct line y lo igualamos a 0,
        // para ver si no se ha detectado ningún comando
        if (line == NULL || line->ncommands == 0) {
            continue; //Volvemos al inicio del while
        }
        
        //Para no tener que estar poniendo "line->commands[0].argc"
        argc = line->commands[0].argc;

        // ==== Mandatos Internos (cd, exit, umask, jobs, fg), Estos se ejecutan en el PROPIO shell, SIN fork. ==== //
        // CASO CD, Funciona correctamente
        if (strcmp(line->commands[0].argv[0], "cd") == 0) {
    
            // CASO 1: msh> cd (Argumentos = 1)
            if (argc == 1) { 
                if (home_dir == NULL) {
                    fprintf(stderr, "cd: No se encontró la variable HOME\n");
            
                } else {
                    // Intenta cambiar al directorio HOME
                    if (chdir(home_dir) == -1) { 
                        perror("cd"); // Error: no existe, permiso, etc.
                    } else { 
                        //Imprime la nueva ruta absoluta
                        if (getcwd(cwd, sizeof(cwd)) != NULL) {
                            printf("%s\n", cwd); 
                        }
                    }
                }
            // CASO 2: msh> cd /ruta (Argumentos > 1, ruta relativa o absoluta)
            } else if (argc > 1) { 
        
                // Intenta cambiar a la ruta especificada por argv[1]
                if (chdir(line->commands[0].argv[1]) == -1) {
                    // ERROR
                    perror("cd"); 
                } else { 
                    //Imprime la nueva ruta absoluta
                    if (getcwd(cwd, sizeof(cwd)) != NULL) {
                        printf("%s\n", cwd); 
                    }
                }
            }
            //NOTA: No se necesita un 'else' para argc > 1, ya que argumentos extra 
            //(p.e. 'cd /ruta argumento_extra') serán ignorados por chdir, que solo mira argv[1].
            continue; //Volvemos al inicio del while
        }

        // CASO EXIT
        if (strcmp(line->commands[0].argv[0], "exit") == 0) {

            exit(0);

        }

        // CASO UMASK
        if (strcmp(line->commands[0].argv[0], "umask") == 0){

            // Si el numero de argumentos es 1, imprimimos la mask actual
            if (argc == 1){

                mode_t old = umask(0); // Devuelve el mask actual cuando le pasamos un mask a poner. mode_t es un tipo para permisos de archivos
                umask(old); // Volvemos a poner el mask que había
                printf("%04o\n", old); // "%04o\n" indica que imprime un numero en octal, con 4 dígitos, rellenando con 0's a la izquierda
                continue;//Volvemos al inicio del while

            }
            
            // Con un argumento (p.e. umask 0777), ponemos las umask que me pasan
            if (argc == 2){
                arg = line->commands[0].argv[1]; 
                // Convertimos de string a octal
                new_mask = strtol(arg, &endptr, 8);

                // Comprobamos que el argumento sea vaĺido (0-0777)
                if (*endptr != '\0' || new_mask < 0 || new_mask > 0777){
                    fprintf(stderr, "umask: mask inválido: %s\n", arg);
                    continue;//Volvemos al inicio del while
                }

                // Cambiamos la mask
                umask((mode_t)new_mask); // Hay que castear a mode_t porque strtol devuelve long
                continue; //Volvemos al inicio del while
            }

            // Si hay más argumentos, error
            fprintf(stderr, "umask: demasiados argumentos\n");
            continue; //Volvemos al inicio del while
        }

        // CASO JOBS
        if (strcmp(line->commands[0].argv[0], "jobs")== 0){

            // Para cada job, imprimimos un mensaje con su info
            for (i = 0; i < num_jobs; i++){
                if (job_list[i].state == RUNNING){ // Imprimimos '+' si es el ultimo job, '-' en otro caso
                    printf("[%d]%c Running   %s\n", job_list[i].job_id, (i == num_jobs-1 ? '+' : '-'), job_list[i].cmdline);
                } else {
                    printf("[%d]%c Stopped   %s\n", job_list[i].job_id, (i == num_jobs-1 ? '+' : '-'), job_list[i].cmdline);
                }
            }
            continue; //Volvemos al inicio del while
        }

        // CASO BG
        // Reanuda un job parado en el background
        if (strcmp(line->commands[0].argv[0], "bg")== 0){
            id_job_a_buscar = -1; //por defecto suponemos que no nos da el id
            
            if(argc > 1){ //p.e bg 2
                id_job_a_buscar = atoi(line->commands[0].argv[1]); //El nuevo id será el argumento pasado (id = 2)
                //Nota: si hubiera más de dos argumentos (p.e. bg 3 4 55) no pasaria nada, solo nos interesa el argv[1]
            }

            job = get_stopped_job(id_job_a_buscar); //cogemos la info del job a buscar

            if(job == NULL){
                fprintf(stderr, "bg: job no encontrado\n"); 
            }else{ 
                //Enviamos la señal SIGCONT (Continue Signal) para reanudar el proceso
                if (kill(job->pid, SIGCONT) < 0){ /*kill(job->pid, SIGCONT) envía una señal SIGCONT al kernel diciendole
                Oye, te acuerdas del proceso con PID 1234 que estaba congelado? Descongélalo y ponlo a trabajar ya*/
                    perror("Error al enviar señal SIGCONT");
                }else{ //Aqui se envió la señal de continuar al proceso con cierto id, y fue exitoso el envio
                    update_job_status(job->pid, RUNNING);//cambiamos el estado de STOPPED a RUNNING
                    //job->state = RUNNING; 
                    printf("[%d]+ Running   %s\n", job->job_id, job->cmdline);
                }
            } // Como la shell no espera a que termine el job, se considera que se hace en el background
            continue; //Volvemos al inicio del while
        }
    
        // ==== MANDATOS EXTERNOS (ls, grep, wc, etc.) ==== //

        pipes = malloc(sizeof(int[2]) * (line->ncommands > 1 ? num_pipes : 1));
        pids_hijos = malloc(sizeof(pid_t) * line->ncommands); // Creamos un array para almacenar los pid de los hijos a crear

        // Bloqueamos temporalmente SIGCHLD
        sigfillset(&mask_all);               // Creamos un set con todas las señales
        /*Bloqueamos SIGCHLD temporalmente, si llega antes de tiempo SIGCHLD la aguantamos
        Es decir, si el hijo acaba muy rapido debemos, obligatoriamente, esperar a que el padre acabe su 
        trabajo (add_job...) pq si no se espera, entonces se produce una condicion de carrera y el hijo
        queda con un "trabajo fantasma" que jamas podría ser borrado*/
        sigprocmask(SIG_BLOCK, &mask_all, &prev_mask); 

        //Crear pipes si ncommands > 1
        if (line->ncommands > 1){ 
            // Crear todos los pipes antes de cualquier fork
            for (j = 0; j < num_pipes; j++) {
                if (pipe(pipes[j]) == -1) { // Al crear el pipe comprobamos directamente si da error
                    perror("Error al crear pipe");
                    exit(EXIT_FAILURE);
                }
            }
        }

        for (i = 0; i < line->ncommands; i++) {  

            pid = fork(); //Crearemos tantos fork como hijos (comandos) haya.

            if (pid < 0) { // Caso error
                fprintf(stderr, "Error en fork: %s\n", strerror(errno));
                exit(1);

            }else if (pid == 0) { // Proceso hijo

                //El hijo ha heredado el bloqueo de TODAS las señales
                //Hay que desbloquearlas para que pueda recibir Ctrl+C / Ctrl+Z
                sigprocmask(SIG_SETMASK, &prev_mask, NULL);
                //Restaurar señales por defecto dependiendo de si es background o no
                if (line->background){ //Si es back debemos ignorar SIGINT (segun el enunciado)
                    signal(SIGINT, SIG_IGN); //ignorar SIGINT
                    /*En la siguiente linea podriamos tener signal(SIGTSTP, SIG_IGN) 
                    ya que asi, si se pulsa crtl + z para detener a un proceso, 
                    no parará el que está en background. Lo dejamos por defecto así*/
                    signal(SIGTSTP, SIG_IGN); 
                }else{ //si no es background ambas señales no son ignoradas 
                    signal(SIGINT, SIG_DFL);
                    signal(SIGTSTP, SIG_DFL); 
                }

                // Redirecciones de Entrada "<" (Solo el primer comando)
                if (i == 0 && line->redirect_input != NULL) { 

                    if ((fd_in = open(line->redirect_input, O_RDONLY)) == -1){
                            fprintf(stderr, "%s: Error. %s\n", line->redirect_input, strerror(errno));
                            exit(1);
                    }

                    //Redirigimos STDIN_FILENO (0) al descriptor del archivo
                    /*Es decir, la entrada estandar pasa de ser el teclado a ser fd_in (un archivo, p.e. fichero.txt)*/
                    dup2(fd_in, STDIN_FILENO);
                    //Cerramos el descriptor original del archivo, ya que STDIN (0) lo usa ahora.
                    close(fd_in);
                }


                //Redirecciones de Salida ">" (Solo el último comando)
                if (i == line->ncommands - 1 && line->redirect_output != NULL) { 
                    // O_WRONLY -> Abre el fichero solo para escritura
                    // O_TRUNC -> Si el fichero ya existe, borra el contenido que tenía
                    // O_CREAT -> Si el fichero no existe, lo crea.
                    // Los siguientes flags son de permisos: S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH
                    // Propietario puede leer y escribir, group puede leer y others puede leer.
                    if ((fd_out = open(line->redirect_output, O_WRONLY|O_TRUNC|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1){
                        fprintf(stderr, "%s: Error. %s\n", line->redirect_output, strerror(errno));
                        exit(1);
                    }

                    //Redirigimos STDOUT_FILENO (1) al descriptor del archivo
                    /*Es decir, la salida estandar pasa de ser la pantalla a ser fd_out (un archivo, p.e. fichero.txt)*/
                    dup2(fd_out, STDOUT_FILENO);
                    close(fd_out);
                }

                //Redirecciones de Salida ERROR "2>" (Solo el último comando)
                if (i == line->ncommands - 1 && line->redirect_error != NULL) { 

                    if ((fd_err = open(line->redirect_error, O_WRONLY|O_TRUNC|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP,S_IROTH)) == -1){
                        fprintf(stderr, "%s: Error. %s\n", line->redirect_error, strerror(errno));
                        exit(1);
                    }

                    dup2(fd_err, STDERR_FILENO); // Cualquier cosa que se mande al descriptor STDERR_FILENO, irá a fd_err
                    close(fd_err); // Cerramos el descriptor fd_err pq no se va a necesitar, pq el proceso usará el STDERR_FILENO
                }

                /*Si el comando actual no es el primero (i > 0), 
                su Entrada Estándar (STDIN_FILENO, descriptor 0) 
                se deberá leer desde el extremo de lectura ([0]) 
                del pipe inmediatamente anterior (pipes[i - 1])*/
                if (i > 0){ 
                    dup2(pipes[i - 1][0], STDIN_FILENO);
                }

                /*Si no es el último mandato... 
                La salida del mandato actual es la entrada del mandato siguiente.*/
                if (i < num_pipes){
                    dup2(pipes[i][1], STDOUT_FILENO);
                }

                // Ahora debemos cerrar todos los descriptores para evitar bloqueos
                // Cerramos todos porque los descriptores que cada proceso va a usar se han duplicado a stdin y stdout.
                for (j = 0; j < num_pipes; j++) {
                    close(pipes[j][0]); // Cierra lectura
                    close(pipes[j][1]); // Cierra escritura
                }

                //Ejecutar mandato
                execvp(line->commands[i].argv[0], line->commands[i].argv); 
                /*Importante: si el hijo es ejecuta ls --> Cuando ls termina de listar, llama internamente a exit(0) y 
                ahi es cuando el kernel envía SIGCHLD al padre
                Cuando muere el proceso hijo, se envia SIGCHLD (ANTES DE ESO, NO)*/

                //Si las siguientes lineas son ejecutadas, es pq no se llamo a exit(0) en execvp y por tanto hubo error
                //En resumen, si no se ejecuta correctamente el exec, mostramos error y salimos
                fprintf(stderr, "%s: No se encuentra el mandato\n", line->commands[i].argv[0]);
                exit(1);
        
            }else { // Proceso padre
                pids_hijos[i] = pid; // Guardamos el PID en el array
            }
        } //fin del for
        
        // Los procesos hijos NO acceden a esta parte
        // Cerramos los extremos de los pipes del padre
        for (j = 0; j < num_pipes; j++) {
            close(pipes[j][0]);
            close(pipes[j][1]);
        }
        
        //Buen padre espera a los hijos 
        //Si no es background, esperamos.
        if (!line->background) { //Si es foreground esperaremos
            for (k = 0; k < line->ncommands; k++) { 
                // Esperamos bloqueantes al hijo k
                // waitpid(pids_hijos[k], &status_fg, WUNTRACED) devuelve > 0 si el hijo:
                // terminó, fue detenido (Ctrl+Z) o murió por una señal.
                // Devuelve -1 en caso de error
                if (waitpid(pids_hijos[k], &status_fg, WUNTRACED) > 0) {
                    // Si el proceso fue parado (Ctrl+Z), hay que añadirlo a jobs
                    if (WIFSTOPPED(status_fg)) {
                        add_job(pids_hijos[k], buf, STOPPED);
                    
                        // IMPORTANTE: next_job_id ya se incrementó dentro de add_job
                        // así que next_job_id-1 es el ID correcto del nuevo job.
                        printf("\n[%d]+ Stopped %s\n", next_job_id - 1, buf);
                    }
                } else {
                    fprintf(stderr, "Error al esperar por un hijo. %s", strerror(errno));
                    exit(1);
                }
            }

        } else { // Si es background (&) añadimos el job a la lista para que si
            // el usuario usa el mandato jobs muestre la lista de trabajos Running y Stopped

            //Añadimos el job a nuestra lista interna
            //Usamos pids_hijos[0] como identificador del proceso líder
            //buf contiene la línea de comandos original
            add_job(pids_hijos[0], buf, RUNNING);

            //Imprimimos el mensaje estándar [ID] PID
            //Como acabamos de añadirlo, su ID es next_job_id - 1
            printf("[%d] %d\n", next_job_id - 1, pids_hijos[0]); 
        }

        //Desbloqueamos la señal SIGCHLD para que el padre sepa que acabo el hijo
        sigprocmask(SIG_SETMASK, &prev_mask, NULL);

        // Liberamos la memoria dinámica usada para los pipes y los pids
        free(pipes);
        free(pids_hijos);
        //free(line);
    
    } // Fin while principal

    return 0;
}