Pipe shares between sibling child processes - c

Question

In following code, I want child c1 blocks (via a pipe) until child c2 done (via call pipe_close() in c2). However it does not work. c1 would block forever. It works if I move pipe_close() out of c2 and put it in parent.
Is this because pipes created from parent are not shareable between sibling children processes?
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>
static void pipe_close(int *);
static void pipe_read(int *);
int
main(void)
{
int pp_main[2] = {-1, -1};
pipe(pp_main);
int ppid = getpid();
int pgid = getpgrp();
int pid_c1 = fork();
if (pid_c1 == 0)
{ // in child c1
int cpid_c1 = getpid();
int gid = getpgrp();
printf("[c1][%d][%d] is made, wait pipe ready\n", cpid_c1, gid);
pipe_read(pp_main);
printf("[c1][%d][%d] done\n", cpid_c1, gid);
}
else
{ // in parent
printf("[main][%d][%d] created child c1: %d\n", ppid, pgid, pid_c1);
int pid_c2 = fork();
if (pid_c2 == 0)
{ // in child c2
int cpid_c2 = getpid();
int gid = getpgrp();
printf("[c2][%d][%d] is made\n", cpid_c2, gid);
for (int i = 2; i > 0; --i)
{
printf("[c2][%d][%d] count down %d\n", cpid_c2, gid, i);
sleep(1);
}
pipe_close(pp_main);
printf("[c2][%d][%d] done\n", cpid_c2, gid);
}
else
{ // in parent
printf("[main][%d][%d] created child c2: %d\n", ppid, pgid, pid_c2);
}
int status;
waitpid(pid_c2, &status, 0);
}
int status;
waitpid(pid_c1, &status, 0);
return 0;
}
static void
pipe_read(int *pp)
{
char ch;
if (pp[1] >= 0)
{
close (pp[1]);
pp[1] = -1;
}
if (pp[0] >= 0)
{
while (read (pp[0], &ch, 1) == -1 && errno == EINTR);
}
}
static void
pipe_close(int *pp)
{
if (pp[0] >= 0)
close (pp[0]);
if (pp[1] >= 0)
close (pp[1]);
pp[0] = pp[1] = -1;
}

Answer 1

It works if I move pipe_close() out of c2 and put it in parent.
That is expected behaviour. A pipe is not fully closed until all references to it are closed. In your code the pipe is created before the fork. Hence both the parent and the child processes have that pipe opened. The c2 child will exit so that closes its references to the pipe. However, the parent process blocks waiting for c1 to exit. Which will never happen because the parent process does not explicitly or implicitly (via exit) close the pipe.