子进程调用dup2致父进程stdin关闭，单管道Shell执行后异常退出

问题根源分析 #

你的Shell在单管道命令执行后直接退出的核心原因有几个，其中最致命的是数组越界导致误关闭了父进程的标准输入，再加上管道描述符的关闭逻辑不完整，具体拆解如下：

1. 数组越界触发未定义行为：当执行单管道命令时（比如ls | grep something），num_commands=2、num_pipes=1，管道数组pipes的大小是1×2。第二次循环i=1时，你执行了close(pipes[i][1])，但pipes的有效索引只有0，这会越界访问内存，大概率误关闭了父进程的stdin（文件描述符0），导致后续fgets直接读到EOF，Shell直接退出。
2. 管道描述符未完全关闭：子进程继承了父进程的所有管道描述符，但你只关闭了部分，这会导致管道写端没有完全关闭，读取的子进程可能无法正常收到EOF；父进程也没有在所有子进程fork完成后关闭管道，进一步加剧了问题。
3. 父进程过早阻塞wait：你在每次fork子进程后立即调用wait，这会让父进程先等当前子进程跑完再创建下一个，虽然不直接导致退出，但不符合管道命令并行执行的预期，也会影响多管道的效率。

修复步骤与修正代码 #

关键修复点

1. 修正管道关闭的索引边界：只有当i < num_pipes时才关闭pipes[i][1]（因为num_pipes = num_commands -1，最后一个子进程没有后续管道）。
2. 子进程关闭所有管道描述符：子进程在重定向后，必须关闭所有管道的两端，避免残留的描述符导致管道无法正常结束。
3. 父进程延迟wait并关闭所有管道：先fork完所有子进程，再关闭父进程持有的管道描述符，最后循环wait等待所有子进程结束。

修正后的核心代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

// 假设你的PARSE_INFO、COMMAND结构体及相关解析函数已正确实现
struct PARSE_INFO {
    int num_commands;
    struct COMMAND** commands;
    int num_pipes;
};

struct COMMAND {
    int argnum;
    char** args;
};

// 省略initialize_parseInfo、Parse、create_argv的实现（你已确认这些函数正常）

int main() {
    char input_line[1000];
    while(fgets(input_line, sizeof(input_line), stdin)) {
        input_line[strcspn(input_line, "\n")] = 0;
        struct PARSE_INFO* parse_info = initialize_parseInfo();
        Parse(input_line, parse_info);
        int num_commands = parse_info->num_commands;
        int num_pipes = parse_info->num_pipes;
        int pipes[num_pipes][2];
        bool piping = num_pipes > 0;

        // 先创建所有需要的管道
        for(int i = 0; i < num_pipes; i++) {
            if (pipe(pipes[i]) == -1) {
                perror("pipe");
                exit(EXIT_FAILURE);
            }
        }

        // 批量创建子进程，不立即wait
        for(int i = 0; i < num_commands; i++) {
            struct COMMAND* command = (parse_info->commands)[i];
            int num_args = command->argnum;
            char* newargv[num_args + 2];
            create_argv(command, newargv, "/usr/bin");

            int pid = fork();
            if(pid == 0) { // 子进程逻辑
                char* newenviron[] = { NULL };

                if(piping) {
                    // 重定向stdout到当前管道写端（非最后一个命令）
                    if(i < num_commands - 1) {
                        dup2(pipes[i][1], STDOUT_FILENO);
                    }
                    // 重定向stdin到上一个管道读端（非第一个命令）
                    if(i > 0) {
                        dup2(pipes[i - 1][0], STDIN_FILENO);
                    }

                    // 关闭所有管道的两端，子进程不再需要这些描述符
                    for(int j = 0; j < num_pipes; j++) {
                        close(pipes[j][0]);
                        close(pipes[j][1]);
                    }
                }

                execve(newargv[0], newargv, newenviron);
                perror("execve");
                exit(EXIT_FAILURE); // execve失败后必须退出子进程
            }
        }

        // 父进程关闭所有管道描述符，不再需要它们
        if(piping) {
            for(int j = 0; j < num_pipes; j++) {
                close(pipes[j][0]);
                close(pipes[j][1]);
            }
        }

        // 等待所有子进程结束
        int status;
        pid_t pid;
        while((pid = wait(&status)) > 0) {
            // 可在此处理子进程退出状态，比如打印错误信息
        }

        // 记得释放解析结构的内存，避免内存泄漏
        // 此处省略内存释放逻辑，请根据你的实现补充
    }
    return 0;
}

额外注意事项 #

• 数组越界是你遇到的直接致命问题，一定要注意num_pipes和num_commands的关系：num_pipes = num_commands -1，所以管道的有效索引是0到num_pipes-1。
• 管道编程的核心原则：所有未使用的管道端必须关闭，不管是父进程还是子进程，否则管道的写端会一直处于打开状态，读取进程会一直等待EOF，导致阻塞或异常。
• 延迟wait能让所有子进程并行执行，符合管道命令的预期行为，也能提升多管道场景的执行效率。

内容的提问来源于stack exchange，提问作者Kareem Aboughazala