how to use pipe to connect two child process in C - c

Question

I am self-studying an OS textbook and doing its homework:
Write a program that creates two children, and connects the standard output of one to the standard input of the other, using the pipe() system call.
then I try to write my code like this:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
int main()
{
printf("parent in pid: (%d)\n", (int)getpid());
fflush(stdout);
int p1[2], p2[2];
pipe(p1);
pipe(p2);
char buff1[100];
char buff2[100];
int rc = fork();
if (rc < 0)
{
fprintf(stderr, "fork failed");
exit(1);
}
else if (rc == 0)
{
int fd = open("test1.txt", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
printf("%d\n", fd);
printf("entering child1 process at pid : (%d)\n", (int)getpid());
dup2(p1[0], STDIN_FILENO);
dup2(p2[1], STDOUT_FILENO);
int n = read(STDIN_FILENO, buff1, sizeof buff1);
puts("this is a message from child 1");
write(fd, buff1, n);
}
else
{
int rc2 = fork();
if (rc2 == 0)
{
int fd2 = open("test2.txt", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
printf("%d\n", fd2);
printf("entering child2 process at pid : (%d)\n", (int)getpid());
dup2(p2[0], STDIN_FILENO);
dup2(p1[1], STDOUT_FILENO);
int n = read(STDIN_FILENO, buff2, sizeof buff2);
puts("this is a message from child 2");
write(fd2, buff2, n);
}
else
{
printf("final parent in pid: (%d)\n", (int)getpid());
}
}
return 0;
}
if all went correctly. I should see messages from child1 or child2 in the txt files. But nothing happened when I run this code.
But if I delete any one of the read statement like this:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
int main()
{
printf("parent in pid: (%d)\n", (int)getpid());
fflush(stdout);
int p1[2], p2[2];
pipe(p1);
pipe(p2);
char buff1[100];
char buff2[100];
int rc = fork();
if (rc < 0)
{
fprintf(stderr, "fork failed");
exit(1);
}
else if (rc == 0)
{
int fd = open("test1.txt", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
printf("%d\n", fd);
printf("entering child1 process at pid : (%d)\n", (int)getpid());
dup2(p1[0], STDIN_FILENO);
dup2(p2[1], STDOUT_FILENO);
//int n = read(STDIN_FILENO, buff1, sizeof buff1);
puts("this is a message from child 1");
//write(fd, buff1, n);
}
else
{
int rc2 = fork();
if (rc2 == 0)
{
int fd2 = open("test2.txt", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
printf("%d\n", fd2);
printf("entering child2 process at pid : (%d)\n", (int)getpid());
dup2(p2[0], STDIN_FILENO);
dup2(p1[1], STDOUT_FILENO);
int n = read(STDIN_FILENO, buff2, sizeof buff2);
puts("this is a message from child 2");
write(fd2, buff2, n);
}
else
{
printf("final parent in pid: (%d)\n", (int)getpid());
}
}
return 0;
}
or like this
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
int main()
{
printf("parent in pid: (%d)\n", (int)getpid());
fflush(stdout);
int p1[2], p2[2];
pipe(p1);
pipe(p2);
char buff1[100];
char buff2[100];
int rc = fork();
if (rc < 0)
{
fprintf(stderr, "fork failed");
exit(1);
}
else if (rc == 0)
{
int fd = open("test1.txt", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
printf("%d\n", fd);
printf("entering child1 process at pid : (%d)\n", (int)getpid());
dup2(p1[0], STDIN_FILENO);
dup2(p2[1], STDOUT_FILENO);
int n = read(STDIN_FILENO, buff1, sizeof buff1);
puts("this is a message from child 1");
write(fd, buff1, n);
}
else
{
int rc2 = fork();
if (rc2 == 0)
{
int fd2 = open("test2.txt", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
printf("%d\n", fd2);
printf("entering child2 process at pid : (%d)\n", (int)getpid());
dup2(p2[0], STDIN_FILENO);
dup2(p1[1], STDOUT_FILENO);
//int n = read(STDIN_FILENO, buff2, sizeof buff2);
puts("this is a message from child 2");
//write(fd2, buff2, n);
}
else
{
printf("final parent in pid: (%d)\n", (int)getpid());
}
}
return 0;
}
I could see correct output in the txt file from both sides.
I'm wondering what happened in my code and what went wrong in the first case?

Answer 1

A few issues in the code:
Both of your child processes block on reading from the pipes, but nothing ever gets written into those, so they block forever. A fix is to write into the pipes before reading.
fflush is required to make sure stdout buffer is written into STDOUT_FILENO. stdout is line-buffered when connected to a terminal, and block-buffered otherwise (the determination is made before main is invoked), so that puts behaves differently when stdout is not connected to a terminal at program start-up.
The parent process should wait for children to terminate. If/when the parent process is a session leader and it terminates, the kernel sends SIGHUP to all (child) processes in its group. More details.
Code with fixes:
int main() {
printf("parent in pid: (%d)\n", (int)getpid());
fflush(stdout);
int p1[2], p2[2];
pipe(p1);
pipe(p2);
char buff1[100];
char buff2[100];
int rc = fork();
if (rc == 0)
{
int fd = open("test1.txt", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
printf("%d\n", fd);
printf("entering child1 process at pid : (%d)\n", (int)getpid());
fflush(stdout);
dup2(p1[0], STDIN_FILENO);
dup2(p2[1], STDOUT_FILENO);
puts("this is a message from child 1");
fflush(stdout);
int n = read(STDIN_FILENO, buff1, sizeof buff1);
write(fd, buff1, n);
}
else
{
int rc2 = fork();
if (rc2 == 0)
{
int fd2 = open("test2.txt", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);
printf("%d\n", fd2);
printf("entering child2 process at pid : (%d)\n", (int)getpid());
fflush(stdout);
dup2(p2[0], STDIN_FILENO);
dup2(p1[1], STDOUT_FILENO);
puts("this is a message from child 2");
fflush(stdout);
int n = read(STDIN_FILENO, buff2, sizeof buff2);
write(fd2, buff2, n);
}
else
{
printf("final parent in pid: (%d)\n", (int)getpid());
waitpid(rc, &rc, 0);
waitpid(rc2, &rc2, 0);
}
}
return 0;
}