Question

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

#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），

编辑：我想我发现了错误：我切换＆＃34;读写＆＃34;管道的两端。

正确的功能：

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);
    }

}

Answer 1

更新：事实证明，我的原始答案远离基础。直到现在我还没完全明白你想做什么。

您的代码大部分是正确的。它不能用于一个非常简单的原因：shell假定命令在启动它的进程完成时完成。

请允许我用一个例子来解释。想象一下，你运行./mypipe a - b - c。

以下是幕后发生的事情：

shell分支进程执行mypipe。这是程序开始执行的时候。
您的程序分叉，父母调用exec(a)。孩子继续解析其他参数并处理管道创建，正如它应该的那样。

所以，现在，在这一点上，你有父运行程序a - 对于shell来说，这是与命令./mypipe对应的进程，你有一个shell进程完全忽略的子进程，执行mypipe的工作 - 设置管道，读取要执行的其余程序等。

所以，现在你有一个竞争条件。由于mypipe后面的进程已被程序a替换，因此只要a终止，shell就会假定您键入的命令已完成（即，它假定为{{1}完成），并打印提示，期望您键入下一个命令。

问题：mypipe很快就会终止，你的子进程仍在浏览其他程序列表并设置管道，重定向输入和输出等等。因此，例如，子进程可能仍在处理创建管道和解析其他程序，而那时a已经完成并将所有内容写入stdout - 哎呀！

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

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

这是代码测试和工作：

args

通过父级执行命令时使用管道

1 个答案: