我要实现一个无名管道，我必须在父进程中执行命令，而不是在他的任何子进程中。每个“-”等于对管道(“|”)的调用，也是分配的一部分 我有这个代码。有人可以向我解释为什么它不起作用吗？

#include <stdio.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h> // for open flags
#include <time.h> // for time measurement
#include <assert.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

void my_exec(char* cmd, char** argv)
{
    int pipefd[2], f;

    if (pipe(pipefd) < 0)
        perror("pipe creation failed");

    f = fork();
    assert(f >= 0);

    if (f == 0) {
        // inside son process - connecting STDOUT to pipe write
      if (dup2(pipefd[1], STDOUT_FILENO) < 0)
            perror("dup2 failed");

        close(pipefd[0]);
        close((int)stdout);


    } else {
        // inside parent process - connecting STDIN to pipe read  and execute command with args
      if (dup2(pipefd[0], STDIN_FILENO) < 0)
            perror("dup2 failed");

        close(pipefd[1]);
       close((int)stdin);



if (execvp(cmd, argv) < 0)
                perror("execvp failed");
        }

}

int main(int argc, char** argv)
{
    assert(strcmp(argv[argc-1], "-"));

    int i;
    for (i = 1; i < argc; ++i) {
        if (!strcmp(argv[i], "-")) {
            argv[i] = NULL;
            my_exec(argv[1], &argv[1]);
            argv = &argv[i];
            argc -= i;
            i = 0;
        }
    }

    char* args[argc];
    args[argc-1] = NULL;

    for (i = 1; i < argc; ++i) {
        args[i-1] = argv[i];
    }

    if (execvp(args[0], args) == -1)
        perror("execvp failed");
    return;
}

命令:

./mypipe.o ls -l - grep "pipe"

返回

total 24
-rw-rw-r-- 1 omer omer 1463 May 23 19:38 mypipe.c
-rwxrwxr-x 1 omer omer 7563 May 23 19:37 mypipe.o
-rw-rw-rw- 1 omer omer  873 May 23 20:01 nice.c
-rwxrwxr-x 1 omer omer 7417 May 23 19:44 nice.o
-rw-rw-r-- 1 omer omer    0 May 23 17:10 try

这显然意味着管道不工作......有什么想法吗？

我需要确保每次调用 np_exec 都会启动一个继续解析其余参数的子进程，而原始父进程会执行给定的程序和参数(使用 execvp)，

编辑: 我想我发现了错误: 我切换管道的“读写”端。

正确的函数:

void np_exec(char* cmd, char** argv)
{
    int pipefd[2];
    int file;

    if (pipe(pipefd) < 0)
        perror("failed to create pipe");

    file = fork();
    assert(file >= 0);

    if (file != 0) {
        // inside parent process - connecting STDOUT to pipe write and execute command with args
      if (dup2(pipefd[WRITE], STDOUT_FILENO) < 0)
            perror("the function dup2 failed");

        close(pipefd[READ]);
        close((int)stdout);

        if (execvp(cmd, argv) < 0)
            perror("the function execvp failed");

    } else {
        // inside son process - connecting STDIN to pipe read
      if (dup2(pipefd[READ], STDIN_FILENO) < 0)
            perror("the function dup2 failed");

        close(pipefd[WRITE]);
       close((int)stdin);
    }

}

最佳答案

更新:结果证明我原来的回答大错特错。直到现在我才完全明白你想做什么。

您的代码大部分是正确的。它不起作用的原因很简单:shell 假定命令在启动它的进程完成时完成。

请允许我用一个例子来解释。假设您运行 ./mypipe a - b - c。

这是幕后发生的事情:

• shell fork 一个进程来执行mypipe。这是您的程序开始执行的时间。

• 您的程序 fork ，父程序调用 exec(a)。 child 继续解析其他参数并处理管道创建，正如它应该做的那样。

所以，现在，此时，您有父级运行程序 a - 在 shell 看来，它是与命令 ./mypipe<>，你有一个 shell 完全忽略的子进程，执行 mypipe 的工作 - 设置管道，读取要执行的其余程序等。

所以，现在你有了一个竞争条件。因为 mypipe 背后的进程已被程序 a 替换，所以一旦 a 终止，shell 就会假定您键入的命令已完成(也就是说，它假定 mypipe 已完成)，并打印提示，希望您键入下一个命令。

问题:a 很快终止，您的子进程仍在遍历其他程序列表并设置管道、重定向输入和输出，等等。因此，例如，子进程可能仍在创建管道并解析其他程序，而此时 a 已经完成并将所有内容写入标准输出 - 糟糕!

你如何解决这个问题？简单:反转命令执行的顺序。首先执行 last 命令，然后是倒数第二个，等等。为什么？因为如果你这样做，父级将是管道上的最后一个，所以它会阻塞等待输入到达管道读取 channel 。当父级终止时，意味着管道中的最后一个命令已经终止，这正是我们想要的。没有竞争条件，shell 不会被欺骗以为我们的命令已完成，而实际上并未完成。

所以，这完全是从右到左而不是从左到右解析程序列表的问题。另外，如果这样做，您将不再需要辅助 args 数组，这太棒了!

这是代码 - 已经过测试并且可以正常工作:

#include <stdio.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h> // for open flags
#include <time.h> // for time measurement
#include <assert.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

void my_exec(char* cmd, char** argv)
{
    int pipefd[2], f;

    if (pipe(pipefd) < 0)
        perror("pipe creation failed");

    f = fork();
    assert(f >= 0);

    if (f == 0) {
        if (dup2(pipefd[1], STDOUT_FILENO) < 0)
            perror("dup2 failed");

        close(pipefd[0]);

    } else {
        if (dup2(pipefd[0], STDIN_FILENO) < 0)
            perror("dup2 failed");

        close(pipefd[1]);

        if (execvp(cmd, argv) < 0)
            perror("execvp failed");
        }
}

int main(int argc, char** argv)
{
    assert(strcmp(argv[argc-1], "-"));

    int i;
    for (i = argc-1; i >= 1; i--) {
        if (!strcmp(argv[i], "-")) {
            argv[i] = NULL;
            my_exec(argv[i+1], &argv[i+1]);
            argc = i;
        }
    }

    if (execvp(argv[0], &argv[1]) == -1)
        perror("execvp failed");

    return 0;
}

关于c - 通过父级执行命令时使用管道，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30415531/