How to implement pipes for multiple processes?

Question

I am creating multiple processes and I need to create two unnamed pipes for each process.

For each child, one pipe will be used to get int value from parent; one for sending to int arrays to parent. Parent will do some things while getting new data from childs.

The base code:

#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h> // for reaching unix operations


int main(int argc, char *argv[]){
    pid_t main = getpid();

    int N = 30;
    int i;
    pid_t* children = (pid_t*) malloc(sizeof(pid_t) * N);
    for(i = 0; i < N; i++){
        pid_t child = fork();
        if ( child == 0){
            pid_t me = getpid();
            printf("I'm a child and my pid is: %d\n", me);
             sleep(1);
            // exit(4);
            return me * 2;
        } else if ( child < 0){
            // printf("Could not create child\n");
        } else {
            children[i] = child;
            // printf("I have created a child and its pid %d\n", child);
        }
    }

    // The child never reaches here
    for(i = 0; i < N; i++){
        int status;
        waitpid(children[i], &status, 0);
        printf("Process %d exited with return code %d\n", children[i], WEXITSTATUS(status));
    }
    return 0;
}

I tried many things with no success and I'm lost. Can you help me to continue?

Any help is appreciated! Thank you.

Answer 1

Here's how to set up one pipe for each child process so that each child writes to the parent:

Since you need two file descriptors for each child, declare:

int fd[2 * N];

Initialize them appropriately:

for (int i = 0; i < N; i++) {
    pipe(&fd[2*i]);
}

---

Inside the i-th child process, use:

write(fd[2*i + 1], write_buffer, SIZE) 

to write to the parent, and in the parent use:

 read(fd[2*i], read_buffer, SIZE) 

to read from the i-th child.

---

To close the pipes:

Inside the i-th child, you can use

close(fd[2*i]) 

right away, seeing as you're only writing. After you're done writing call

close(fd[2*i + 1]) 

to close the write end of the pipe.

The situation is parallel in the parent: when reading from the i-th child you can

close(fd[2*i + 1]) 

right away, since you're not writing, and after you're done reading call

close(fd[2*i])

to close the read end of the pipe.

---

Since you need two pipes per child process, create two arrays - one containing pipes for the children writing to the parent, and one containing pipes for the parent writing to the children.