将 posix pipe() 和 dup() 与 C++ 一起使用重定向 I/O 问题

Question

我必须修改为之前的家庭作业编写的一个简单 shell 来处理 I/O 重定向，但我在使管道正常工作时遇到了困难。似乎当我在单独的进程中复制文件描述符后写入和读取到 stdout 和从 stdin 时，管道可以工作，但是如果我使用 printf、fprintf、gets、fgets 等类似的东西来尝试查看输出是否是显示在管道中，它会转到控制台，即使标准输入和标准输出的文件描述符显然是管道的副本（我不知道这是否是正确的表达方式，但我认为这一点很清楚） 。

我 99.9% 确定我所做的一切至少应该是在普通 C 中——例如在 dup() 之后适当地关闭所有文件描述符——并且文件 I/O 工作正常，所以这似乎是一个问题我不知道也找不到任何信息的细节。我花了一天的大部分时间尝试不同的事情，过去几个小时在谷歌上搜索试图弄清楚我是否可以将 cin 和 cout 重定向到管道，看看是否可以修复它，但似乎这比它的价值更麻烦这一点。

由于 cin 和 cout 应该与 stdio 同步，因此应该仅通过重定向 stdin 和 stdout 来工作吗？我认为应该如此，特别是因为这些命令可能是用 C 编写的，所以我认为它们会使用 stdio。但是，如果我尝试像“cat [file1] [file2] | sort”这样的命令，它会将 cat [file1] [file2] 的结果打印到命令行，并且 sort 不会获得任何输入，因此它没有输出。很明显，cout和cin也不受dup()的影响，所以我把两个和两个放在一起得出了这个结论 这是我的代码的一个稍微缩短的版本，减去了所有错误检查和类似的东西，我相信我处理得很好。如果需要的话，我可以发布完整的代码，但是代码很多，所以我将从这个开始。

我重写了该函数，以便父进程为每个命令分叉一个子进程，并根据需要将它们与管道连接，然后等待子进程终止。同样，文件描述符 0 和 1 上的写入和读取工作（即写入管道和从管道读取），文件指针 stdin 和 stdout 上的 stdio 不起作用（不写入管道）。

非常感谢，这一直杀了我...

更新：我没有更改每个不同命令的字符串 cmd，所以它似乎不起作用，因为管道只是转到相同的命令，所以最终输出是同样......抱歉我的愚蠢，但是谢谢，因为我发现了 strace 的问题。

int call_execv( string cmd, vector<string> &argv, int argc,
    vector<int> &redirect)
{
    int result = 0, pid, /* some other declarations */;
    bool file_in, file_out, pipe_in, pipe_out;
    queue<int*> pipes; // never has more than 2 pipes

    // parse, fork, exec, & loop if there's a pipe until no more pipes
    do
    {
        /* some declarations for variables used in parsing */
        file_in = file_out = pipe_in = pipe_out = false;

        // parse the next command and set some flags
        while( /* there's more redirection */ )
        {
            string symbol = /* next redirection symbol */

            if( symbol == ">" )
            {
                /* set flags, get filename, etc */
            }   
            else if( symbol == "<" )
            {
                /* set flags, get filename, etc */
            }
            else if( pipe_out = (symbol == "|") )
            {
                    /* set flags, and... */
                int tempPipes[2];               
                pipes.push( pipe(tempPipes) );
                break;
            }
        }

        /* ... set some more flags ... */

        // fork child
        pid = fork();
        if( pid == 0 )  // child
        {
            /* if pipe_in and pipe_out set, there are two pipes in queue. 
            the old pipes read  is dup'd to stdin, and the new pipes
            write is dup'd to stdout, other two FD's are closed */

            /* if only pipe_in or pipe_out, there is one pipe in queue.
            the unused end is closed in whichever if statement evaluates */

            /* if neither pipe_in or pipe_out is set, no pipe in queue */

            // redirect stdout
            if( pipe_out ){
                // close newest pipes read end
                close( pipes.back()[P_READ] );

                // dup the newest pipes write end
                dup2( pipes.back()[P_WRITE], STDOUT_FILENO );

                // close newest pipes write end
                close( pipes.back()[P_WRITE] );
            }
            else if( file_out ) 
                freopen(outfile.c_str(), "w", stdout);

            // redirect stdin
            if( pipe_in ){
                close( pipes.front()[P_WRITE] );
                dup2( pipes.front()[P_READ], STDIN_FILENO );
                close( pipes.front()[P_READ] );
            }
            else if ( file_in ) 
                freopen(infile.c_str(), "r", stdin);


            // create argument list and exec
            char **arglist = make_arglist( argv, start, end );
            execv( cmd.c_str(), arglist );

            cout << "Execution failed." << endl;    
            exit(-1); // this only executes is execv fails

        }   // end child

        /* close the newest pipes write end because child is writing to it.
           the older pipes write end is closed already */
        if( pipe_out ) 
            close( pipes.back()[P_WRITE] );

        // remove pipes that have been read from front of queue
        if( init_count > 0 )    
        {
            close( pipes.front()[P_READ] ); // close FD first
            pipes.pop();                    // pop from queue
        }   

    } while ( pipe_out );

    // wait for each child process to die

    return result;
}

Answer 1

无论出现什么问题，您都没有检查任何返回值。您如何知道 pipe() 或 dup2() 命令是否成功？您是否已验证 stdout 和 stdin 确实指向 execv 之前的管道？ execv 是否保留您提供的文件描述符？不确定，这里是 execve 文档中的相应段落：

• 默认情况下，文件描述符在 execve() 中保持打开状态。标记为 close-on-exec 的文件描述符被关闭；参见fcntl(2)中FD_CLOEXEC的描述。 （如果一个
  文件描述符被关闭，这将导致该进程在底层文件上获得的所有记录锁被释放。有关详细信息，请参阅 fcntl(2)。）POSIX.1-2001 说
  如果文件描述符 0、1 和 2 在成功的 execve() 后被关闭，并且进程将获得特权，因为 set-user_ID 或 set-group_ID per-
  如果在执行的文件上设置了任务位，则系统可能会为每个文件描述符打开一个未指定的文件。作为一般原则，没有可移植程序，
  无论是否有特权，都可以假设这三个文件描述符将在 execve() 期间保持关闭状态。

您应该添加更多调试输出，看看到底发生了什么。您是否在程序中使用了strace -f（跟踪孩子）？

Answer 2

以下内容：

queue<int*> pipes; // never has more than 2 pipes
// ...
int tempPipes[2];               
pipes.push( pipe(tempPipes) );

不应该工作。不确定它是如何编译的，因为 pipe() 是 int。请注意，tempPipes 超出范围，其内容会丢失。

应该是这样的：

struct PipeFds
{
    int fds[2];
};

std::queue<PipeFds> pipes;
PipeFds p;
pipe(p.fds); // check the return value
pipes.push(p);