在C中管道，dup，close和exec的问题

Question

Well. I kinda understand how pipes work and why is dup/dup2 used before an exec in any child process.

But I need help with the 'close(int fd)' thing. To make it clear I would like to ask you for any pseudocode or any C code example which does the following:

1. Parent gets a fd from a file using open().
2. Parent creates a child which execs to another program which reads data from the open() func fd used before and writes the output in a pipe. (So parent should wait it to end before continuing).
3. Same parent then creates another child which is going to exec and read from that write end of the pipe created before and write the output in the stdo.

Is it even posible to do this with only one pipe?

The tricky thing here for me is not creating the pipe and redirecting channels with dup2 and stuff, it is knowing where and when to close() all the fd channels.

If you could explain me how to do a thing like that and when and where to close the channels with an example I think I would definetly understand it all.

Thanks a lot guys.

Answer 1

Below is a complete example. WhozCraig already told that there's no need for parent to wait for child 1 to end before continuing, since child 2 has to read the pipe until EOF. (On the contrary, the parent must not wait, because the pipe buffer might not be large enough to hold all the file data.) Of course there's only one pipe needed, where child 1 writes to one end and child 2 reads from the other. And for that no dup is needed.

When and where does the parent have to close the pipe channels?

The parent may close the pipe ends as soon as it doesn't need them any longer, provided that a child which needs a pipe end has it open, ie in our case, the parent may close (its descriptor of) the write end after child 1 has been forked, and the parent may close the read end after child 2 has been forked, since the children inherit the pipe descriptors, and they remain usable until the children close them at exit.

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

main(int argc, char *argv[])
{
    if (argc <= 1) return 1;
    int fd = open(argv[1], O_RDONLY);   // Parent gets a fd from a file.
    if (fd < 0) return perror(argv[1]), 1;
    int pipefd[2];
    if (pipe(pipefd) < 0) return perror("pipe"), 1;
    char in[8], out[8];
    sprintf(in,  "FD:%d", fd);          // reads data from the open() func fd
    sprintf(out, "FD:%d", pipefd[1]);   // writes the output in a pipe
    switch (fork())
    {   // Parent creates a child which execs to another program, e. g. "socat"
    case -1:    return perror("fork 1"), 1;
    case  0:    execlp("socat", "socat", "-u", in, out, NULL);
                return perror("execlp 1"), 1;
    }
    close(pipefd[1]);   // parent may close write end, since child has it open
    sprintf(in,  "FD:%d", pipefd[0]);   // read from the pipe created before
    sprintf(out, "FD:%d", 1);           // write the output in the stdo
    switch (fork())
    {   // Same parent then creates another child which is going to exec
    case -1:    return perror("fork 2"), 1;
    case  0:    execlp("socat", "socat", "-u", in, out, NULL);
                return perror("execlp 2"), 1;
    }
    close(pipefd[0]);   // parent may close read end, since child has it open
}