exec.c

#include "exec.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

/* ===== Внутренние команды ===== */

int execute_cd(char **args) {
    if (!args[1]) {
        /* cd без аргументов -> HOME */
        char *home = getenv("HOME");
        if (!home) {
            fprintf(stderr, "cd: HOME not set\n");
            return 1;
        }
        if (chdir(home) != 0) {
            perror("cd");
            return 1;
        }
    } else {
        if (chdir(args[1]) != 0) {
            perror("cd");
            return 1;
        }
    }
    return 0;
}

int execute_pwd(void) {
    char cwd[1024];
    if (getcwd(cwd, sizeof(cwd))) {
        printf("%s\n", cwd);
        return 0;
    } else {
        perror("pwd");
        return 1;
    }
}

int execute_exit(void) {
    exit(0);
    return 0; /* never reached */
}

/* ===== Вспомогательные функции ===== */

/* Открыть файл для перенаправления */
static int open_redirection(const char *filename, int flags, mode_t mode) {
    int fd = open(filename, flags, mode);
    if (fd < 0) {
        perror(filename);
        exit(1);
    }
    return fd;
}

/* Выполнить одну простую команду */
static int execute_simple_command(Command *cmd) {
    /* Проверка внутренних команд */
    if (cmd->argv && cmd->argv[0]) {
        if (strcmp(cmd->argv[0], "cd") == 0) {
            return execute_cd(cmd->argv);
        }
        if (strcmp(cmd->argv[0], "pwd") == 0) {
            return execute_pwd();  // ИСПРАВЛЕНО: без аргументов
        }
        if (strcmp(cmd->argv[0], "exit") == 0) {
            return execute_exit();
        }
    }
    
    /* Внешняя команда */
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    }
    
    if (pid == 0) { /* Дочерний процесс */
        /* Перенаправление ввода */
        if (cmd->infile) {
            int fd = open_redirection(cmd->infile, O_RDONLY, 0);
            dup2(fd, STDIN_FILENO);
            close(fd);
        }
        
        /* Перенаправление вывода */
        if (cmd->outfile) {
            int flags = O_WRONLY | O_CREAT;
            flags |= cmd->append ? O_APPEND : O_TRUNC;
            int fd = open_redirection(cmd->outfile, flags, 0644);
            dup2(fd, STDOUT_FILENO);
            close(fd);
        }
        
        /* Фоновый режим: перенаправить stdin в /dev/null */
        if (cmd->background) {
            int null_fd = open("/dev/null", O_RDONLY);
            if (null_fd >= 0) {
                dup2(null_fd, STDIN_FILENO);
                close(null_fd);
            }
        }
        
        /* Выполнить команду */
        execvp(cmd->argv[0], cmd->argv);
        
        /* Если дошли сюда, execvp не удался */
        fprintf(stderr, "%s: command not found\n", cmd->argv[0]);
        exit(127);
    }
    
    /* Родительский процесс */
    if (cmd->background) {
        /* Не ждём фоновый процесс */
        printf("[%d] started\n", pid);
        return 0;
    } else {
        /* Ждём завершения */
        int status;
        waitpid(pid, &status, 0);
        return WEXITSTATUS(status);
    }
}

/* Выполнить конвейер */
static int execute_pipeline(Command *cmd) {
    int pipefd[2];
    int prev_read = -1;
    int status = 0;
    Command *current = cmd;
    
    while (current) {
        /* Создаём канал, если это не последняя команда */
        if (current->pipe) {
            if (pipe(pipefd) < 0) {
                perror("pipe");
                return 1;
            }
        }
        
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork");
            return 1;
        }
        
        if (pid == 0) { /* Дочерний процесс */
            /* Подключаем ввод от предыдущей команды */
            if (prev_read != -1) {
                dup2(prev_read, STDIN_FILENO);
                close(prev_read);
            }
            
            /* Подключаем вывод к следующей команде */
            if (current->pipe) {
                close(pipefd[0]); /* Не читаем из своего выхода */
                dup2(pipefd[1], STDOUT_FILENO);
                close(pipefd[1]);
            }
            
            /* Закрываем все оставшиеся дескрипторы каналов */
            if (prev_read != -1) close(prev_read);
            if (current->pipe) close(pipefd[0]);
            
            /* Выполняем команду */
            execvp(current->argv[0], current->argv);
            fprintf(stderr, "%s: command not found\n", current->argv[0]);
            exit(127);
        }
        
        /* Родитель: закрываем ненужные дескрипторы */
        if (prev_read != -1) close(prev_read);
        if (current->pipe) {
            close(pipefd[1]); /* Закрываем запись для родителя */
            prev_read = pipefd[0]; /* Читаем из канала для следующей команды */
        }
        
        current = current->pipe;
    }
    
    /* Ждём завершения всех процессов в конвейере */
    while (wait(NULL) > 0);
    
    return status;
}

/* ===== Основные функции ===== */

int execute_command(Command *cmd) {
    if (!cmd) return 0;
    
    switch (cmd->type) {
        case CMD_SIMPLE:
            return execute_simple_command(cmd);
            
        case CMD_PIPE:
            /* Находим первую команду в конвейере */
            while (cmd->left) cmd = cmd->left;
            return execute_pipeline(cmd);
            
        case CMD_SEQ:
            execute_command(cmd->left);
            return execute_command(cmd->right);
            
        case CMD_BACKGROUND:
            cmd->left->background = 1;
            return execute_command(cmd->left);
    }
    
    return 0;
}

void cleanup_background_processes(void) {
    pid_t pid;
    int status;
    
    /* Проверяем завершённые фоновые процессы без блокировки */
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        printf("[%d] done\n", pid);
    }
}