管道和流程

Question

前提： 编写一个程序来向用户查询两个输入字符串。每个输入字符串应该是一个 UNIX 命令，允许使用参数。例如，输入 1 可以是 ls -l，输入 2 可以是 more。然后程序将创建一个管道和两个子进程。第一个子进程将运行第一个输入中指定的命令。它将输出到管道而不是标准输出。第二个子进程将运行第二个输入中指定的命令。它将从管道获取输入而不是标准输入。父进程将等待其两个子进程完成，然后整个过程将重复。当输入“@”符号作为第一个命令时，执行将停止。这是我的代码：

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

int main(){

    /* Program Termination Symbol */
    const char terminate = '@';

    /* String delimiter */
    const char delimiter = ' ';

    /* Pipe file ID's */
    int fileID[2];

    /* Parent ID's */
    int pid1, pid2;

    /* String token */
    char * token, * token2;

    /* User input */
    char * user_input, line[100];

    user_input = (char *) malloc(100);

    /* Unix Commands */
    char * command1[10], *command2[10];

    for (int i=0; i<10; i++)
    {
    command1[i] = (char *)malloc(100*sizeof(char));
    command2[i] = (char *)malloc(100*sizeof(char));
    }

    /* Begin main program logic */

    printf("Please enter the first command: \n");

    user_input = gets(line);

    while (user_input[0] != terminate)
    {
    token = (char *) malloc(100*sizeof(char));

    for (int i=0; i<10; i++)
        {
        if (i == 0)
        {
        token = strtok(user_input, &delimiter); 
        } else {
        token = strtok(NULL, &delimiter);
        }

        if (token != NULL)
        {
        strcpy(command1[i], token);
        } else {
        command1[i] = 0;
        }
        }

    printf("Please enter the second command: \n");  
    user_input = gets(line);

    token2 = (char *) malloc(100*sizeof(char));

    for (int i=0; i<10; i++)
    {
        if (i == 0)
        {
        token2 = strtok(user_input, &delimiter);
        } else {
        token2 = strtok(NULL, &delimiter);
        }

        if (token2 != NULL)
        {
        strcpy(command2[i], token2);
        } else {
        command2[i] = 0;
        }
    }   


    /* Pipe and execute user commands */

    /* Create pipe */
    pipe(fileID);

    /* Create child processes */

    pid1 = fork();

    if (pid1 != 0)
    {
        pid2 = fork();
    }

    /* First child process */
    if (pid1 == 0)
    {
        dup2(fileID[1], 1);
        execvp(command1[0], command1);
    }

    /* Second child process */
    if (pid2 == 0)
    {
        dup2(fileID[0], 0);
        execvp(command2[0], command2);
    }   

    /* Wait for children to terminate */
    wait(&pid1);
    wait(&pid2);

    /* Repeat */
        printf("Please enter the first command: \n");
    user_input = gets(line);
    }

    return 0;
}

我遇到的问题是我的等待。如果我两者都有，这对我来说是有意义的（每个孩子一个等待），那么程序在执行第一个管道后就会冻结。如果我删除第二个等待，那么程序将再次开始循环，但不会接受除 Enter 之外的键盘输入，并且会产生段错误。因此，在等待过程中，输入和输出都是……

Please enter the first command:
ls
Please enter the second command:
more
Pipe
Pipe.c
Pipe.c~

然后它就锁定了。如果我删除第二个等待，输入/输出是...

Please enter the first command:
ls
Please enter the second command:
more
Pipe
Pipe.c
Pipe.c~
Please enter the first command:
(I hit enter, nothing else will work)
Segmentation fault

有人有什么建议吗？这显然与等待两个进程有关，但我不知道如何处理它。

---

该程序现已 100% 正常运行 - 非常感谢大家的帮助！堆栈溢出一直是互联网上最好的资源之一。非常感谢大家花时间查看我的代码并给我建议。

Answer 1

我同意托拉克所说的一切，但要解决你的问题，你需要关闭管道。我认为你“悬而未决”，因为管道仍然打开。

因此，在父级中，在“等待”之前，我会关闭管道。

close(fileID[0]);
close(fileID[1]);
wait(&pid_status);
wait(&pid_status);

然后，在每次 execvp 之前，我会关闭孩子不会使用的管道的末端：

close(fileID[0]);
dup2(fileID[1], 1);
execvp(command1[0], command1);


close(fileID[1]);
dup2(fileID[0], 0);
execvp(command2[0], command2);

这应该可以解决您的挂起问题。除了 torak 提出的建议之外，我还建议使用 fgets 而不是 gets 来防止缓冲区溢出。

Answer 2

有几件事。不确定它们是否是造成您问题的原因，但在提交作业之前仍然需要考虑一些事情。

1. 我认为您没有正确使用wait。根据http://linux.die.net/man/2/wait不将 pid 指针作为参数。

2. 循环时，您都会为 token 和 token2 调用 malloc，但我没有看到相应的内存释放。

3. 您已经编写了一个整体函数。良好的编码实践建议将其分解为子例程的集合

4. 最后，并且它可能与第 3 点相关，以下两行代码在您的代码中出现了两次。再说一遍，这不是错误，而是不必要的重复，而且不优雅。

   printf("请输入第一条命令：\n");
   user_input = gets(line);

Answer 3

首先，您也在子进程中调用 wait [编辑：不，您没有，因为每个子进程都调用 execvp]。

另外，wait 并不采用指向子进程 pid 的指针，而是指向将写入进程状态的变量（这意味着您将丢弃子进程的 pid）。

最后，尝试将 waitpid 与“WNOHANG”选项一起使用。它不会挂起，您可以在执行其他操作时将两者置于循环中，并且可以通过检查状态变量来检查子进程是否已退出。 man waitpid。