CODEWITHSUNDEEP
cpipeforklow-level
koneru nikhil
koneru nikhil

Reputation: 339

Why child process is waiting while using fork and pipes for stdin from parent's output?

I understood how fork and pipes work but i have a doubt regarding the flow of the child and parent process.Since we are using fork the order of execution of parent and child process is undefined but why child process is waiting for stdin from parent process.What happens if child process executes first? it must print empty in console? but it is not happening can i know why?

#include <stdio.h> 
#include <sys/types.h> 
#include <sys/wait.h> 
#include <unistd.h>
int main () {
int fds[2]; pid_t pid;
/* File descriptors for the two ends of the pipe are placed in fds. */
pipe (fds);
/* Fork a child process. */ 
pid = fork ();
if (pid == (pid_t) 0) {
/* Child proces -. Close the write end of the file descriptor. */
close (fds[1]);
/* Connect the read end of the pipe to standard input. */
dup2 (fds[0], STDIN_FILENO);
/* Replace the child process with the “rev” program. */
execlp("rev", "rev", 0); }

else {
/* This is the parent process. */
    FILE* stream;
/* Close the read end of the file descriptor. */
    close (fds[0]);
/* Convert the write file descriptor to a FILE object */
    stream = fdopen (fds[1], "w");
    fprintf (stream, ",ereh ot ereht morF\n");
    fprintf (stream, ",ereht ot ereh dna\n");
    fprintf (stream, ".erehwyreve era sgniht ynnuf\n"); 
    fprintf (stream, "ssueS .rD - \n");
    fflush (stream);
    close (fds[1]);
/* Wait for the child process to finish. */
    waitpid (pid, NULL, 0);
}
    return 0; 
}

Upvotes: 0

Views: 1070

Answers (1)

Jonathan Leffler
Jonathan Leffler

Reputation: 753475

You aren't closing enough file descriptors in the child.

Rule of thumb: If you dup2() one end of a pipe to standard input or standard output, close both of the original file descriptors returned by pipe() as soon as possible. In particular, you should close them before using any of the exec*() family of functions.

The rule also applies if you duplicate the descriptors with either dup() or fcntl() with F_DUPFD

In this case, the child needs to close fds[1] after duplicating it. Because it is still open, rev will never receive EOF because there is a process (the rev child process) that could, in theory, write to the input.

You should use fclose(stream) instead of close(fds[1]) because the output is buffered and fclose() knows to flush the buffers, but close() hasn't got a clue. However, by using fflush(stream) before the misguided close(), you do avoid problems.

That leads to:

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

int main(void)
{
    int fds[2];
    pid_t pid;

    pipe(fds);

    pid = fork();
    if (pid == (pid_t)0)
    {
        close(fds[1]);
        dup2(fds[0], STDIN_FILENO);
        close(fds[0]);
        execlp("rev", "rev", 0);
    }
    else
    {
        FILE *stream;
        close(fds[0]);
        stream = fdopen(fds[1], "w");
        fprintf(stream, ",ereh ot ereht morF\n");
        fprintf(stream, ",ereht ot ereh dna\n");
        fprintf(stream, ".erehwyreve era sgniht ynnuf\n");
        fprintf(stream, "ssueS .rD - \n");
        fclose(stream);
        waitpid(pid, NULL, 0);
    }
    return 0;
}

which produces the output:

From there to here,
and here to there,
funny things are everywhere.
 - Dr. Seuss

Upvotes: 4

Related Questions