Unix C - 将stdout重定向到管道然后再返回到stdout

Question

I'm not sure if the following can be done because I cannot find any questions/results via Google on it. I want to change stdout of a fork() to a pipe, and then change it back to the normal stdout.

This is what I have:

FirstExecutable:

int main()
{
      int fd[2]; //Used for pipe
      int processID;

      if(pipe(fd) == -1)
      {
            printf("Error - Pipe error.\n");
            exit(EXIT_FAILURE);
      }

      if((processID = fork()) == -1)
      {
            fprintf(stderr, "fork failure");
            exit(EXIT_FAILURE);
      }

      if(processID == 0)
      {
           int newFD = dup(STDOUT_FILENO);

          char newFileDescriptor[2];

          sprintf(newFileDescriptor, "%d", newFD);

          dup2 (fd[1], STDOUT_FILENO);

          close(fd[0]);

          execl("./helloworld", "helloworld", newFileDescriptor, NULL);
      }
      else
      { 
          close(fd[1]);

          char c[10];

          int r = read(fd[0],c, sizeof(char) * 10);

          if(r > 0)
               printf("PIPE INPUT = %s", c);
      }
}

helloworld

int main(int argc, char **argv)
{
      int oldFD = atoi(argv[1]);

      printf("hello\n"); //This should go to pipe

      dup2(oldFD, STDOUT_FILENO);

      printf("world\n"); //This should go to stdout
}

Desired Output:

world
PIPE OUTPUT = hello

Actual Output:

hello
world

Answer 1

Try changing

  printf("hello\n");

to

  printf("hello\n");
  fflush(stdout);

The issue here is buffering. For efficiency reasons FILE handles don't always produce output immediately when written to. Instead they accumulate text in an internal buffer.

There are three buffering modes, unbuffered, line buffered, and block buffered. Unbuffered handles always write immediately (stderr is unbuffered). Line buffered handles wait until the buffer is full or a newline ( '\\n' ) is printed (stdout is line buffered if it refers to a terminal). Block buffered handles wait until the buffer is full (stdout is block buffered if it doesn't refer to a terminal).

When your helloworld program starts up, stdout goes to a pipe, not a terminal, so it's set up as block buffered. The printf calls therefore simply store the text in memory. Since the buffer doesn't get full, it is only flushed when stdout is closed, which in this case happens when the program exits.

But by the time the program exits, file descriptor 1 (stdout) has been restored to refer to the parent's original stdout, not the pipe. Thus the buffered output ends up being written to the original stdout.

fflush forces the buffered text to be written immediately.