c - c中的 fork 和管道过程

Question

所以我有一个项目要做，但我完全被难住了。我花了十个小时，却一无所获。我并不是特别想要答案的代码，但是一些伪代码和正确方向的良好提示会有所帮助!!

它派生出许多进程，k - 一个命令行参数，通过管道连接 - 每个进程都连接到下一个进程，最后一个进程连接到第一个进程。进程号 k 将其消息发送到进程号 (k+1)%n。

进程 0 从 stdin 读取一行。然后它将它传输到进程 1。每个其他进程读取该行，将字符串的第一个字节递增 1，然后将该行中继到下一个进程。在进行中继时，它会打印一条状态消息(如下所示)。

当消息返回到进程 0 时，它也被输出到标准输出。当进程接收到 EOF(来自管道，如果它不是 0 的进程，或者来自 stdin，对于进程 0)，它打印最终字符串。这将关闭所有管道。

预期的输出是:

$ ./ring 4
hello
process #0 (32768) sending message: hello
process #1 (32769) relaying message: iello
process #2 (32770) relaying message: jello
process #3 (32767) relaying message: kello
I hear kello
^C
$

到目前为止我写了什么:

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

#define BUFFER_SIZE 80
#define READ_END 0
#define WRITE_END 1

int main(int argc, char *argv[])
{
    char readmsg[BUFFER_SIZE], readmsg2[BUFFER_SIZE], final[BUFFER_SIZE];
    int pid, process;
    int parent_child[2], child_parent[2];
    process = 0;

    if (pipe(child_parent) == -1) {
        fprintf(stderr, "Pipe failed");
        return 1;
    }
    if (pipe(parent_child) == -1) {
        fprintf(stderr, "Pipe failed");
        return 1;   
    }

    pid = fork();
    if (pid < 0) {
        fprintf(stderr, "Fork failed");
        return 1;
    } else if (pid > 0) {
        /* PARENT */
        read(0, &readmsg, BUFFER_SIZE);
        printf("process #%d (%d) sending message: %s", 
            0, getpid(), readmsg);
        write(parent_child[WRITE_END], &readmsg, BUFFER_SIZE);
        close(parent_child[WRITE_END]);
    } else {
        /* CHILD */
        read(parent_child[READ_END], &readmsg2, BUFFER_SIZE);
        readmsg2[0] += 1;
        printf("process #%d (%d) relaying message: %s", 
            1, getpid(), readmsg2);
        process += 1;
        write(child_parent[WRITE_END], &readmsg2, BUFFER_SIZE);
    }

    read(child_parent[READ_END], &final, BUFFER_SIZE);
    printf("I hear %d %s", pid - getpid(), final);

    return 0;
}

它当前所做的是从 stdin 中读取字符串，将其传递给第一个进程并打印进程 0(虽然实际上无法获取 0，只是打印 0)，然后将字符串通过管道传输到进程 1，这会扭曲字节 1，然后再次写入管道，然后在管道外，读取字符串并输出扭曲的字符串。

$ ./ring
hello
process #0 (6677) sending message: hello
process #1 (6678) relaying message: iello
I hear -6678 iello
^C
$ 

我不知道从这里去哪里。提前谢谢你，任何事情都会有帮助!!

在一些帮助下，这就是我现在所拥有的:

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

#define BUFFER_SIZE 80
#define READ_END 0
#define WRITE_END 1

int main(int argc, char **argv) {
    char buf[BUFFER_SIZE];
    int process, rings, pid, pid_n, pid_n1, pid_1, i;
    int Pn[2];   //Pipe for process n   -> 0
    int Pn_1[2]; //Pipe for process n-1 -> n
    int Pn_2[2]; //Pipe for process n-2 -> n-1
    int P_0[2];  //Pipe for process 0   -> 1
    process = 0;

    if (argc == 2) {
        rings = atoi(argv[1]);
    } else {
        fprintf(stderr, "Usage: %s n, where n is number of rings\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    if ((pid = fork()) < 0) {
        fprintf(stderr, "Fork failed");
        return 1;
    } else if (pid == 0) {
        if ((pid_n = fork()) < 0) {
            fprintf(stderr, "Fork failed");
            return 1;
        } else if (pid_n == 0) {
            /* CHILD */
            close(Pn[WRITE_END]);
            close(Pn_1[READ_END]);
        } else {
            /* PARENT */
            close(Pn[READ_END]);
            close(Pn_1[WRITE_END]);
        }
        for (i = 0; i < rings; i++) {
            if ((pid_n1 = fork()) < 0) {
                fprintf(stderr, "Fork failed");
                return 1;
            } else if (pid_n1 == 0) {
                /* CHILD */
                close(Pn_1[WRITE_END]);
                close(Pn_2[READ_END]);
            } else {
                /* PARENT */
                close(Pn_1[READ_END]);
                close(Pn_2[WRITE_END]);
            }
        }

        /* Not sure about these last ones */
        if ((pid_1 = fork()) < 0) {
            fprintf(stderr, "Fork failed");
            return 1;
        } else if (pid_1 == 0) {
            /* CHILD */
            close(P_n2[WRITE_END]);
            close(P_0[READ_END]);

        } else {
            /* PARENT */
            close(P_n2[READ_END]);
            close(P_0[WRITE_END]);
        }
    } else {
        /* PARENT */
        read(0, &buf, BUFFER_SIZE);
        buf[BUFFER_SIZE - 1] = '\0';
        printf("process first # (%d) sending message: %s", getpid(), buf);
        write(P_0[WRITE_END], &buf, BUFFER_SIZE);
        read(Pn[READ_END], &buf, BUFFER_SIZE);
        buf[BUFFER_SIZE - 1] = '\0';
        printf("I hear %s", buf);
    }

    return 0;
}

Answer 1

这是我自己画的图，展示了流程是如何相互连接的:

                  p4
           C5 <--------- C4
          /               \
     p5  /              p3 \
        /                   \
o----> C0 ---->o            C3
        \                   /
     p0  \              p2 /
          \               /
           C1 ---------> C2
                  p1

Cn 代表进程； C0是父进程。 pn 代表管道；另外两行是标准输入和标准输出。每个 child 都有一项适合 child 的简单任务。父级有一个更复杂的任务，主要是确保关闭正确数量的文件描述符。事实上，close() 非常重要，以至于我创建了一个调试函数 fd_close()，以有条件地报告正在关闭的文件描述符。当我在代码中出现愚蠢的错误时，我也会使用它。

err_*() 函数是我在大多数程序中使用的代码的简化版本。它们通过将大多数错误报告转换为单行语句而不是要求多行来使错误报告变得不那么繁重。 (这些函数通常在“stderr.c”和“stderr.h”中，但这些文件有 750 行代码和注释，而且更全面。生产代码有一个选项支持为每个消息加上 PID 前缀，这是对于像这样的多进程系统也很重要。)

#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

enum { BUFFER_SIZE = 1024 };

typedef int Pipe[2];

static int debug = 0;
static void fd_close(int fd);

/* These functions normally declared in stderr.h */
static void err_setarg0(const char *argv0);
static void err_sysexit(char const *fmt, ...);
static void err_usage(char const *usestr);
static void err_remark(char const *fmt, ...);

static void be_childish(Pipe in, Pipe out)
{
    /* Close irrelevant ends of relevant pipes */
    fd_close(in[1]);
    fd_close(out[0]);
    char buffer[BUFFER_SIZE];
    ssize_t nbytes;
    while ((nbytes = read(in[0], buffer, sizeof(buffer))) > 0)
    {
        buffer[0]++;
        if (write(out[1], buffer, nbytes) != nbytes)
            err_sysexit("%d: failed to write to pipe", (int)getpid());
    }
    fd_close(in[0]);
    fd_close(out[1]);
    exit(0);
}

int main(int argc, char **argv)
{
    err_setarg0(argv[0]);

    int nkids;
    if (argc != 2 || (nkids = atoi(argv[1])) <= 1 || nkids >= 10)
        err_usage("n   # for n in 2..9");

    err_remark("Parent  has PID %d\n", (int)getpid());

    Pipe pipelist[nkids];
    if (pipe(pipelist[0]) != 0)
        err_sysexit("Failed to create pipe #%d", 0);
    if (debug)
        err_remark("p[0][0] = %d; p[0][1] = %d\n", pipelist[0][0], pipelist[0][1]);

    for (int i = 1; i < nkids; i++)
    {
        pid_t pid;
        if (pipe(pipelist[i]) != 0)
            err_sysexit("Failed to create pipe #%d", i);
        if (debug)
            err_remark("p[%d][0] = %d; p[%d][1] = %d\n", i, pipelist[i][0], i, pipelist[i][1]);
        if ((pid = fork()) < 0)
            err_sysexit("Failed to create child #%d", i);
        if (pid == 0)
        {
            /* Close irrelevant pipes */
            for (int j = 0; j < i-1; j++)
            {
                fd_close(pipelist[j][0]);
                fd_close(pipelist[j][1]);
            }
            be_childish(pipelist[i-1], pipelist[i]);
            /* NOTREACHED */
        }
        err_remark("Child %d has PID %d\n", i, (int)pid);
    }

    /* Close irrelevant pipes */
    for (int j = 1; j < nkids-1; j++)
    {
        fd_close(pipelist[j][0]);
        fd_close(pipelist[j][1]);
    }

    /* Close irrelevant ends of relevant pipes */
    fd_close(pipelist[0][0]);
    fd_close(pipelist[nkids-1][1]);

    int w_fd = pipelist[0][1];
    int r_fd = pipelist[nkids-1][0];

    /* Main loop */
    char buffer[BUFFER_SIZE];

    while (printf("Input:  ") > 0 && fgets(buffer, sizeof(buffer), stdin) != 0)
    {
        int len = strlen(buffer);
        if (write(w_fd, buffer, len) != len)
            err_sysexit("Failed to write to children");
        if (read(r_fd, buffer, len) != len)
            err_sysexit("Failed to read from children");
        printf("Output: %.*s", len, buffer);
    }
    fd_close(w_fd);
    fd_close(r_fd);
    putchar('\n');

    int status;
    int corpse;
    while ((corpse = wait(&status)) > 0)
        err_remark("%d exited with status 0x%.4X\n", corpse, status);

    return 0;
}

static void fd_close(int fd)
{
    if (debug)
        err_remark("%d: close(%d)\n", (int)getpid(), fd);
    if (close(fd) != 0)
        err_sysexit("%d: Failed to close %d\n", (int)getpid(), fd);
}

/* Normally in stderr.c */
static const char *arg0 = "<undefined>";

static void err_setarg0(const char *argv0)
{
    arg0 = argv0;
}

static void err_usage(char const *usestr)
{
    fprintf(stderr, "Usage: %s %s\n", arg0, usestr);
    exit(1);
}

static void err_vsyswarn(char const *fmt, va_list args)
{
    int errnum = errno;
    fprintf(stderr, "%s:%d: ", arg0, (int)getpid());
    vfprintf(stderr, fmt, args);
    if (errnum != 0)
        fprintf(stderr, " (%d: %s)", errnum, strerror(errnum));
    putc('\n', stderr);
}

static void err_sysexit(char const *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    err_vsyswarn(fmt, args);
    va_end(args);
    exit(1);
}

static void err_remark(char const *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    vfprintf(stderr, fmt, args);
    va_end(args);
}

示例输出:

$  ./pipecircle 9
Parent  has PID 34473
Child 1 has PID 34474
Child 2 has PID 34475
Child 3 has PID 34476
Child 4 has PID 34477
Child 5 has PID 34478
Child 6 has PID 34479
Child 7 has PID 34480
Child 8 has PID 34481
Input:  Hello
Output: Pello
Input:  Bye
Output: Jye
Input:  ^D
34474 exited with status 0x0000
34477 exited with status 0x0000
34479 exited with status 0x0000
34476 exited with status 0x0000
34475 exited with status 0x0000
34478 exited with status 0x0000
34480 exited with status 0x0000
34481 exited with status 0x0000
$