executor_heredoc.c

Bu dosyanın dokümantasyonuna git.

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   executor_heredoc.c                                 :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: hgenc <hgenc@student.42kocaeli.com.tr>     +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2026/01/26 17:39:45 by hgenc             #+#    #+#             */
/*   Updated: 2026/02/19 15:00:00 by hgenc            ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */
 
/**
 * @file executor_heredoc.c
 * @brief Heredoc implementasyonu (fork tabanlı)
 *
 * Heredoc okuma child process'te yapılır.
 * readline yerine write+read kullanılır (cooked mode, SIG_DFL çalışır).
 * Ctrl-C → child SIG_DFL ile ölür, parent terminali düzeltir.
 */
 
#include "../../include/minishell.h"
#include <signal.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <termios.h>
#include <unistd.h>
 
/**
 * @brief Heredoc için bir satır oku (readline yerine read kullanır)
 * @return char* Okunan satır (malloc), EOF: NULL
 *
 * Cooked mode'da read() Enter'a kadar bekler, tüm satırı döner.
 * SIG_DFL bu modda doğru çalışır (readline override etmez).
 */
static char *heredoc_read_line(void)
{
    char    buf[4096];
    char    c;
    ssize_t ret;
    int     i;
 
    i = 0;
    while (i < 4095)
    {
        ret = read(STDIN_FILENO, &c, 1);
        if (ret <= 0)
            break ;
        if (c == '\n')
            break ;
        buf[i++] = c;
    }
    if (i == 0 && ret <= 0)
        return (NULL);
    buf[i] = '\0';
    return (ft_strdup(buf));
}
 
/**
 * @brief Heredoc satırlarını oku ve pipe'a yaz (child process)
 */
static void heredoc_child(t_shell *shell, t_redir *redir, int write_fd)
{
    char            *line;
    struct termios  term;
 
    signal(SIGINT, SIG_DFL);
    signal(SIGQUIT, SIG_IGN);
    tcgetattr(STDIN_FILENO, &term);
    term.c_lflag |= (ICANON | ECHO | ISIG);
    term.c_iflag &= ~(IGNCR);
    term.c_iflag |= ICRNL;
    term.c_oflag |= (OPOST | ONLCR);
    tcsetattr(STDIN_FILENO, TCSANOW, &term);
    while (1)
    {
        write(2, "> ", 2);
        line = heredoc_read_line();
        if (!line)
        {
            ft_putstr_fd("minishell: warning: heredoc delimited by EOF\n", 2);
            break ;
        }
        if (ft_strcmp(line, redir->file) == 0)
        {
            free(line);
            break ;
        }
        if (!redir->quoted)
            line = expand_heredoc_line(shell, line);
        if (!write_heredoc_line(write_fd, line))
        {
            free(line);
            break ;
        }
        free(line);
    }
}
 
/**
 * @brief Heredoc redirection uygula (fork tabanlı)
 * @param shell Shell structure
 * @param redir Redirection yapısı
 * @return int başarı: fd, hata/iptal: -1
 *
 * Child process heredoc'u okur (write+read, readline değil).
 * Ctrl-C: child ölür (SIG_DFL), parent terminali düzeltir.
 */
int redir_heredoc(t_shell *shell, t_redir *redir)
{
    int             pipefd[2];
    pid_t           pid;
    int             status;
    struct termios  saved_term;
 
    if (!redir || !redir->file)
        return (-1);
    if (!create_heredoc_pipe(pipefd))
        return (-1);
    tcgetattr(STDIN_FILENO, &saved_term);
    signal(SIGINT, SIG_IGN);
    pid = fork();
    if (pid == 0)
    {
        close(pipefd[0]);
        heredoc_child(shell, redir, pipefd[1]);
        close(pipefd[1]);
        shell_exit(shell, 0);
    }
    close(pipefd[1]);
    waitpid(pid, &status, 0);
    tcflush(STDIN_FILENO, TCIFLUSH);
    tcsetattr(STDIN_FILENO, TCSANOW, &saved_term);
    setup_signals();
    if (WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
    {
        close(pipefd[0]);
        write(1, "\n", 1);
        shell->exit_status = 130;
        return (-1);
    }
    return (pipefd[0]);
}