c - C 中的这种多管道代码有意义吗？

Question

我创建了一个 question about this a few days .我的解决方案与已接受答案中建议的内容一致。然而，我的一个 friend 提出了以下解决方案:

请注意，代码已经更新了几次(检查编辑修订)以反射(reflect)下面答案中的建议。如果您打算给出一个新的答案，请记住这个新代码而不是有很多问题的旧代码。

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char *argv[]){
    int fd[2], i, aux, std0, std1;

    do {
        std0 = dup(0); // backup stdin
        std1 = dup(1); // backup stdout

        // let's pretend I'm reading commands here in a shell prompt
        READ_COMMAND_FROM_PROMPT();

        for(i=1; i<argc; i++) {
            // do we have a previous command?
            if(i > 1) {
                dup2(aux, 0);
                close(aux);
            }

            // do we have a next command?
            if(i < argc-1) {
                pipe(fd);

                aux = fd[0];
                dup2(fd[1], 1);
                close(fd[1]);
            }

            // last command? restore stdout...
            if(i == argc-1) {
                dup2(std1, 1);
                close(std1);
            }

            if(!fork()) {
                // if not last command, close all pipe ends
                // (the child doesn't use them)
                if(i < argc-1) {
                    close(std0);
                    close(std1);
                    close(fd[0]);
                }

                execlp(argv[i], argv[i], NULL);
                exit(0);
            }
        }

        // restore stdin to be able to keep using the shell
        dup2(std0, 0);
        close(std0);
    }

    return 0;
}

这模拟了一系列通过管道的命令，就像在 bash 中一样，例如:cmd1 |命令2 | ... |命令_n。我说“模拟”，因为如您所见，命令实际上是从参数中读取的。只是为了业余时间编写一个简单的 shell 提示...

当然还有一些问题需要修复和添加错误处理，但这不是这里的重点。我想我有点明白代码了，但它仍然让我很困惑整个事情是如何工作的。

我是不是遗漏了什么，或者这真的有效，而且它是解决问题的一个很好而干净的解决方案？如果没有，谁能指出这段代码存在的关键问题？

Answer 1

看起来很合理，虽然它确实需要修复泄漏的 std 和 aux 到子级和循环之后，以及父级的原始 stdin永远失去了。

如果有颜色可能会更好......

./a.out foo bar baz <stdin >stdoutstd = dup(stdout)     ||     |+==========================std                      ||     ||                          ||pipe(fd)              ||     ||    pipe1[0] -- pipe0[1]  ||                      ||     ||       ||          ||     ||aux = fd[0]           ||     ||      aux          ||     ||                      ||     XX       ||          ||     ||                      ||      /-------++----------+|     ||dup2(fd[1], 1)        ||     //       ||          ||     ||                      ||     ||       ||          ||     ||close(fd[1])          ||     ||       ||          XX     ||                      ||     ||       ||                 ||fork+exec(foo)        ||     ||       ||                 ||                      XX     ||       ||                 ||                       /-----++-------+|                 ||dup2(aux, 0)          //     ||       ||                 ||                      ||     ||       ||                 ||close(aux)            ||     ||       XX                 ||                      ||     ||                          ||pipe(fd)              ||     ||    pipe2[0] -- pipe2[1]  ||                      ||     ||       ||          ||     ||aux = fd[0]           ||     ||      aux          ||     ||                      ||     XX       ||          ||     ||                      ||      /-------++----------+|     ||dup2(fd[1], 1)        ||     //       ||          ||     ||                      ||     ||       ||          ||     ||close(fd[1])          ||     ||       ||          XX     ||                      ||     ||       ||                 ||fork+exec(bar)        ||     ||       ||                 ||                      XX     ||       ||                 ||                       /-----++-------+|                 ||dup2(aux, 0)          //     ||       ||                 ||                      ||     ||       ||                 ||close(aux)            ||     ||       XX                 ||                      ||     ||                          ||pipe(fd)              ||     ||    pipe3[0] -- pipe3[1]  ||                      ||     ||       ||          ||     ||aux = fd[0]           ||     ||      aux          ||     ||                      ||     XX       ||          ||     ||                      ||      /-------++----------+|     ||dup2(fd[1], 1)        ||     //       ||          ||     ||                      ||     ||       ||          ||     ||close(fd[1])          ||     ||       ||          XX     ||                      ||     XX       ||                 ||                      ||      /-------++-----------------+|dup2(std, 1)          ||     //       ||                 ||                      ||     ||       ||                 ||fork+exec(baz)        ||     ||       ||                 ||

• foo gets stdin=stdin, stdout=pipe1[1]
• bar gets stdin=pipe1[0], stdout=pipe2[1]
• baz gets stdin=pipe2[0], stdout=stdout

---

My suggestion is different in that it avoids mangling the parent's stdin and stdout, only manipulating them within the child, and never leaks any FDs. It's a bit harder to diagram, though.

for cmd in cmds
    if there is a next cmd
        pipe(new_fds)
    fork
    if child
        if there is a previous cmd
            dup2(old_fds[0], 0)
            close(old_fds[0])
            close(old_fds[1])
        if there is a next cmd
            close(new_fds[0])
            dup2(new_fds[1], 1)
            close(new_fds[1])
        exec cmd || die
    else
        if there is a previous cmd
            close(old_fds[0])
            close(old_fds[1])
        if there is a next cmd
            old_fds = new_fds

parent    cmds = [foo, bar, baz]    fds = {0: stdin, 1: stdout}cmd = cmds[0] {    there is a next cmd {        pipe(new_fds)            new_fds = {3, 4}            fds = {0: stdin, 1: stdout, 3: pipe1[0], 4: pipe1[1]}    }    fork             => child                        there is a next cmd {                            close(new_fds[0])                                fds = {0: stdin, 1: stdout, 4: pipe1[1]}                            dup2(new_fds[1], 1)                                fds = {0: stdin, 1: pipe1[1], 4: pipe1[1]}                            close(new_fds[1])                                fds = {0: stdin, 1: pipe1[1]}                        }                        exec(cmd)    there is a next cmd {        old_fds = new_fds            old_fds = {3, 4}    }}cmd = cmds[1] {    there is a next cmd {        pipe(new_fds)            new_fds = {5, 6}            fds = {0: stdin, 1: stdout, 3: pipe1[0], 4: pipe1[1],                                        5: pipe2[0], 6: pipe2[1]}    }    fork             => child                        there is a previous cmd {                            dup2(old_fds[0], 0)                                fds = {0: pipe1[0], 1: stdout,                                       3: pipe1[0], 4: pipe1[1],                                       5: pipe2[0], 6: pipe2[1]}                            close(old_fds[0])                                fds = {0: pipe1[0], 1: stdout,                                                    4: pipe1[1],                                       5: pipe2[0]  6: pipe2[1]}                            close(old_fds[1])                                fds = {0: pipe1[0], 1: stdout,                                       5: pipe2[0], 6: pipe2[1]}                        }                        there is a next cmd {                            close(new_fds[0])                                fds = {0: pipe1[0], 1: stdout, 6: pipe2[1]}                            dup2(new_fds[1], 1)                                fds = {0: pipe1[0], 1: pipe2[1], 6: pipe2[1]}                            close(new_fds[1])                                fds = {0: pipe1[0], 1: pipe1[1]}                        }                        exec(cmd)    there is a previous cmd {        close(old_fds[0])            fds = {0: stdin, 1: stdout,              4: pipe1[1],                                        5: pipe2[0], 6: pipe2[1]}        close(old_fds[1])            fds = {0: stdin, 1: stdout, 5: pipe2[0], 6: pipe2[1]}    }    there is a next cmd {        old_fds = new_fds            old_fds = {3, 4}    }}cmd = cmds[2] {    fork             => child                        there is a previous cmd {                            dup2(old_fds[0], 0)                                fds = {0: pipe2[0], 1: stdout,                                       5: pipe2[0], 6: pipe2[1]}                            close(old_fds[0])                                fds = {0: pipe2[0], 1: stdout,                                                    6: pipe2[1]}                            close(old_fds[1])                                fds = {0: pipe2[0], 1: stdout}                        }                        exec(cmd)    there is a previous cmd {        close(old_fds[0])            fds = {0: stdin, 1: stdout,              6: pipe2[1]}        close(old_fds[1])            fds = {0: stdin, 1: stdout}    }}

---

Edit

Your updated code does fix the previous FD leaks… but adds one: you're now leaking std0 to the children. As Jon says, this is probably not dangerous to most programs... but you still should write a better behaved shell than this.

Even if it's temporary, I would strongly recommend against mangling your own shell's standard in/out/err (0/1/2), only doing so within the child right before exec. Why? Suppose you add some printf debugging in the middle, or you need to bail out due to an error condition. You'll be in trouble if you don't clean up your messed-up standard file descriptors first. Please, for the sake of having things operate as expected even in unexpected scenarios, don't muck with them until you need to.

---

Edit

As I mentioned in other comments, splitting it up into smaller parts makes it much easier to understand. This small helper should be easily understandable and bug-free:

/* cmd, argv: passed to exec
 * fd_in, fd_out: when not -1, replaces stdin and stdout
 * return: pid of fork+exec child
 */
int fork_and_exec_with_fds(char *cmd, char **argv, int fd_in, int fd_out) {
    pid_t child = fork();
    if (fork)
        return child;

    if (fd_in != -1 && fd_in != 0) {
        dup2(fd_in, 0);
        close(fd_in);
    }

    if (fd_out != -1 && fd_in != 1) {
        dup2(fd_out, 1);
        close(fd_out);
    }

    execvp(cmd, argv);
    exit(-1);
}

应该这样:

void run_pipeline(int num, char *cmds[], char **argvs[], int pids[]) {
    /* initially, don't change stdin */
    int fd_in = -1, fd_out;
    int i;

    for (i = 0; i < num; i++) {
        int fd_pipe[2];

        /* if there is a next command, set up a pipe for stdout */
        if (i + 1 < num) {
            pipe(fd_pipe);
            fd_out = fd_pipe[1];
        }
        /* otherwise, don't change stdout */
        else
            fd_out = -1;

        /* run child with given stdin/stdout */
        pids[i] = fork_and_exec_with_fds(cmds[i], argvs[i], fd_in, fd_out);

        /* nobody else needs to use these fds anymore
         * safe because close(-1) does nothing */
        close(fd_in);
        close(fd_out);

        /* set up stdin for next command */
        fd_in = fd_pipe[0];
    }
}

可以看到Bash从 execute_cmd.c#execute_pipeline 调用的 execute_cmd.c#execute_disk_command，xsh从 jobs.c#job_run 调用的 process.c#process_run，甚至是 BusyBox 中的每一个的 various small and minimal shells将它们分开。