Using pipes to communicate between a parent and a child

Question

In an attempt to better understand how pipes work in C, I decided to create a simple program. It is supposed to do the following: Firstly, I fork the program. The parent then reads from the standard input and writes everything into a pipe until EOF is reached. The child then reads from that pipe and writes the content back into another pipe, which is then supposed to be read by the parent process and written into the standard output.

Yes, the program isn't very "useful", but I'm just trying to familiarize myself with pipes and how to use them. This is my code:

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

int main(int argc, char **argv) {
    char buf;
    int pipe_one[2];
    int pipe_two[2];
    pid_t child;

    if(pipe(pipe_one) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    if(pipe(pipe_two) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    child = fork();
    switch (child) {
        case -1:
            fprintf(stderr, "Error while forking.\n");
            break;
        case 0:
            // child
            // close unnecessary ends
            close(pipe_one[1]);
            close(pipe_two[0]);

            // read input from parent and write it into pipe
            while(read(pipe_one[0], &buf, 1) > 0) {
                write(pipe_two[1], &buf, 1);
            }
            write(pipe_two[1], "\n", 1);
            close(pipe_one[0]);
            close(pipe_two[1]);
            break;
        default:
            // parent
            // close unnecessary ends
            close(pipe_one[0]);
            close(pipe_two[1]);

            // read from standard input and write it into pipe
            while(read(STDIN_FILENO, &buf, 1) > 0) {
                write(pipe_one[1], &buf, 1);
            }
            write(pipe_one[1], "\n", 1);
            close(pipe_one[1]);

            // wait for child process to finish
            wait(NULL);

            // read from pipe that child wrote into
            while(read(pipe_two[0], &buf, 1) > 0) {
                write(STDOUT_FILENO, &buf, 1);
            }
            write(STDOUT_FILENO, "\n", 1);
            close(pipe_two[0]);
            break;
    }

    exit(EXIT_SUCCESS);
}

Expected behavior: In the beginning, the program reads user input until EOF is reached and then it outputs everything again into the standard output.

Actual behavior: The program reads the whole input, but once EOF is reached it just terminates (succesfully) without writing anything into the standard output. What am I doing wrong? I'd be happy if someone could look over it and help me out.

Answer 1

You close pipes for your parent in your child.

while(read(pipe_one[0], &buf, 1) > 0) {
                write(pipe_two[1], &buf, 1);
            }
write(pipe_two[1], "\n", 1);
close(pipe_one[0]); // Here you close pipes
close(pipe_two[1]); // for your parent

So the parent can't receive anything. Just remove those two lines and it will work.