C语言命令行解释器管道文件描述符处理问题排查

你的命令行解释器出现Bad file descriptor错误，核心问题在于未初始化的管道描述符被误关闭，以及父进程管道描述符管理不规范，具体问题和修复如下：

核心问题点 #

1. 误关闭未初始化的文件描述符
   当处理最后一个命令时，代码无条件执行close(fd1[1]); close(fd2[1]);，但如果管道fd2从未被pipe()初始化（比如管道命令只有2个时），fd2[1]是未定义的垃圾值，可能恰好等于标准输入（0）、输出（1）等有效描述符，导致这些关键描述符被错误关闭，后续进程读取/写入时触发错误。

2. 父进程未及时关闭无用管道描述符
   第一个命令执行后，父进程未关闭fd1的读写端，导致管道写端始终被父进程持有，最后一个子进程可能无法收到EOF（虽然你的例子中未卡住，但这是潜在的阻塞问题）。

3. 重复关闭文件描述符
   部分分支中存在重复关闭同一描述符的情况（比如i=0的子进程两次关闭fd1[0]），虽不致命，但不符合规范。

修复后的代码 #

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

// 假设params和lst相关定义已存在

int main() {
    // 初始化管道描述符为无效值，避免误关未打开的fd
    int fd1[2] = {-1, -1};
    int fd2[2] = {-1, -1};
    int i, pid, len;
    // 假设params.cnt_prog和lst已正确初始化

    for (i = 0; i < params.cnt_prog; i++) {
        len = proc_len(lst);
        char* buf[len + 1];
        lst2buf(&lst, buf);
        buf[len] = NULL;

        int* curr_pipe = NULL;
        // 仅当不是最后一个命令时，创建新管道
        if (i < params.cnt_prog - 1) {
            if (i % 2 == 0) {
                curr_pipe = fd1;
                if (pipe(fd1) == -1) {
                    perror("pipe");
                    exit(EXIT_FAILURE);
                }
            } else {
                curr_pipe = fd2;
                if (pipe(fd2) == -1) {
                    perror("pipe");
                    exit(EXIT_FAILURE);
                }
            }
        }

        pid = fork();
        if (pid == 0) {
            /* 处理输入：连接到上一个管道的读端 */
            if (i > 0) {
                int* prev_pipe = (i % 2 == 1) ? fd1 : fd2;
                if (dup2(prev_pipe[0], STDIN_FILENO) == -1) {
                    perror("dup2 stdin");
                    exit(EXIT_FAILURE);
                }
                // 关闭上一个管道的所有描述符（子进程已复制到标准输入）
                close(prev_pipe[0]);
                close(prev_pipe[1]);
            } else {
                // 第一个命令处理输入重定向
                if (!redirect_in(&params)) {
                    exit(EXIT_FAILURE);
                }
            }

            /* 处理输出：连接到当前管道的写端（非最后一个命令） */
            if (i < params.cnt_prog - 1) {
                if (dup2(curr_pipe[1], STDOUT_FILENO) == -1) {
                    perror("dup2 stdout");
                    exit(EXIT_FAILURE);
                }
                // 关闭当前管道的所有描述符（子进程已复制到标准输出）
                close(curr_pipe[0]);
                close(curr_pipe[1]);
            } else {
                // 最后一个命令：关闭所有已打开的管道，处理输出重定向
                if (fd1[0] != -1) {
                    close(fd1[0]);
                    close(fd1[1]);
                }
                if (fd2[0] != -1) {
                    close(fd2[0]);
                    close(fd2[1]);
                }
                if (!redirect_out(&params)) {
                    exit(EXIT_FAILURE);
                }
            }

            execvp(buf[0], buf);
            perror(buf[0]);
            exit(EXIT_FAILURE);
        } else if (pid == -1) {
            perror("fork");
            exit(EXIT_FAILURE);
        }

        /* 父进程管理管道描述符 */
        // 关闭上一个命令的管道（子进程已使用完毕）
        if (i > 0) {
            int* prev_pipe = (i % 2 == 1) ? fd1 : fd2;
            close(prev_pipe[0]);
            close(prev_pipe[1]);
            // 重置为无效值，避免后续误操作
            prev_pipe[0] = -1;
            prev_pipe[1] = -1;
        }
        // 关闭当前管道的写端（父进程不需要写入，子进程会处理）
        if (i < params.cnt_prog - 1) {
            close(curr_pipe[1]);
        }
    }

    // 等待所有子进程执行完毕
    while (wait(NULL) != -1);

    return 0;
}

关键修复说明 #

1. 初始化管道描述符：将fd1和fd2初始化为-1，通过判断值是否为-1来确认管道是否已被创建，避免误关未打开的描述符。
2. 精准关闭管道：最后一个命令仅关闭已创建的管道，不会触碰未初始化的垃圾值。
3. 父进程及时清理：
   • 非第一个命令：fork后立即关闭上一个管道的所有描述符（子进程已继承并使用，父进程无需保留）。
   • 非最后一个命令：关闭当前管道的写端（父进程不写入，仅保留读端给下一个子进程）。
4. 添加错误检查：对pipe()和dup2()的返回值做校验，便于调试管道创建失败的情况。
5. 等待子进程结束：添加wait()循环，确保父进程等待所有子进程执行完毕，避免子进程成为孤儿进程，同时保证管道资源被正确释放。

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