How does stuff have to be ordered when using dup2 and pipe?

Question

I am currently trying to understand combincation of dup2 and C pipes, but not even the simplest program seems to work. Already when reading example codes I am pretty confused on when they close ends of the pipe and where the output should be printed.

Sometimes the write end is closed, even though one line later output should be generated which should go into the pipe. In other examples, the unused end is closed (which makes more sense to me).

Then, I do not understand when dup2 should be executed. I guess it should become before the output I want to redirect, but I have the feeling I also saw that differently today.

So in the end I came up with this little test with printf and fflush in each line, where nothing gets redirected through the pipe. Why's that? What am I doing wrong?

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int out_pipe[2];
    char *output[101];

    if (pipe(out_pipe) != 0) {
        perror("pipe()");
        exit(1);
    }

    printf("Hello");
    fflush(stdout);

    dup2(out_pipe[1], STDOUT_FILENO);
    printf("Hello");
    fflush(stdout);

    close(out_pipe[1]);
    printf("Hello");
    fflush(stdout);

    read(out_pipe[0], output, 100);
    close(out_pipe[0]);

    printf("PIPE: %s", output);
    fflush(stdout);

    return 0;
}

Answer 1

1. End your printf() messages with newlines; the fflush() is still a good idea as you're about to change where standard output goes, though it's not usually necessary if the standard output of the program is going to a terminal. If the standard output was going to a file and the fflush() was not in place, then you'd get three copies of "Hello\n" written to the pipe.

2. When you change standard output to the pipe, your message is indeed written to the pipe.

3. When you close the write file descriptor, you don't run into any issues. You then write a second Hello to the pipe. You need this fflush() to ensure that the standard I/O package has actually written its buffered data to the pipe.

4. You then read from the pipe into the output buffer. You should check how many bytes you read since the string is not going to be null terminated. You should get 10 bytes read (when you don't have any newlines in the messages).

5. You then write to the pipe again with the PIPE: prefix.

To fix, write messages to standard error.

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int out_pipe[2];
    char output[101];

    if (pipe(out_pipe) != 0) {
        perror("pipe()");
        exit(1);
    }

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

    dup2(out_pipe[1], STDOUT_FILENO);
    printf("Hello\n");
    fflush(stdout);

    close(out_pipe[1]);
    printf("Hello\n");
    fflush(stdout);

    int n = read(out_pipe[0], output, sizeof(output));
    close(out_pipe[0]);

    fprintf(stderr, "PIPE: %.*s\n", n, output);

    return 0;
}

Note that I changed the definition of output from an array of char * to a simple array of char. With the changes, I got the output:

$ ./pipe3
Hello
PIPE: Hello
Hello

$

That's because I included newlines in the messages written to the pipe, as well as in the format string that ends up on standard error.

---

Is there a possibility to "reenable" stdout?

Yes; simply preserve a copy of the original file descriptor for standard output before using dup2(), and then reinstate the copy once you've done with the pipe.

I've removed the two leading fflush() calls, and the sample output demonstrates the difference between terminal and file output:

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int out_pipe[2];
    char output[101];
    int old_stdout;

    if (pipe(out_pipe) != 0) {
        perror("pipe()");
        exit(1);
    }

    printf("Hello\n");

    old_stdout = dup(STDOUT_FILENO);

    dup2(out_pipe[1], STDOUT_FILENO);
    printf("Hello\n");

    close(out_pipe[1]);
    printf("Hello\n");
    fflush(stdout);

    int n = read(out_pipe[0], output, sizeof(output));
    close(out_pipe[0]);

    dup2(old_stdout, STDOUT_FILENO);
    printf("PIPE: %d <<%.*s>>\n", n, n, output);

    return 0;
}

Sample outputs:

$ ./pipe3Hello
PIPE: 12 <<Hello
Hello
>>
$./pipe3 > output
'pipe3' is up to date.
$ cat output
PIPE: 18 <<Hello
Hello
Hello
>>
$

If you remove the remaining fflush(), the program hangs. There is nothing in the pipe (because standard I/O hasn't flushed its buffer because it isn't full and the output isn't a terminal any more), but the pipe is open for writing, so the kernel considers that input could appear on it — if only the program that has the pipe open for writing wasn't waiting on the read end of the pipe for the input to appear. The program has deadlocked on itself.