#define _GNU_SOURCE
#include <unistd.h>
#include <fcntl.h>

int pipe2(int filedes[2], int flags);
/* Returns 0 on success, -1 on error */

/* flags can be:
 *   0            — same as pipe()
 *   O_CLOEXEC    — set FD_CLOEXEC on both fds
 *   O_NONBLOCK   — set O_NONBLOCK on both fds
 *   O_CLOEXEC | O_NONBLOCK — both at once
 */

If flags = 0, pipe2() behaves exactly like pipe(). The benefit is that flags are set atomically at creation time — no race window between pipe() and a subsequent fcntl() call.

By default, file descriptors survive across exec() calls. This means if a process creates a pipe and then calls exec() to replace itself with another program, the new program inherits the pipe descriptors — which is almost never what you want.

FD_CLOEXEC (the close-on-exec flag) tells the kernel to automatically close a file descriptor when exec() is called.

Example 1: pipe2() with O_CLOEXEC

/* cloexec_demo.c */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>

int main(void)
{
    int pfd[2];

    /* Create pipe with close-on-exec flag */
    if (pipe2(pfd, O_CLOEXEC) == -1) {
        perror("pipe2");
        return 1;
    }

    printf("Created pipe: fd[0]=%d, fd[1]=%d\n", pfd[0], pfd[1]);

    /* Verify FD_CLOEXEC is set */
    int flags0 = fcntl(pfd[0], F_GETFD);
    int flags1 = fcntl(pfd[1], F_GETFD);
    printf("fd[0] FD_CLOEXEC set: %s\n", (flags0 & FD_CLOEXEC) ? "YES" : "NO");
    printf("fd[1] FD_CLOEXEC set: %s\n", (flags1 & FD_CLOEXEC) ? "YES" : "NO");

    /* If we exec() here, pfd[0] and pfd[1] would be auto-closed */

    /* Compare: old way needed two extra fcntl() calls */
    int pfd2[2];
    pipe(pfd2);
    /* Old way to set close-on-exec: */
    fcntl(pfd2[0], F_SETFD, FD_CLOEXEC);  /* extra call 1 */
    fcntl(pfd2[1], F_SETFD, FD_CLOEXEC);  /* extra call 2 */
    /* pipe2(O_CLOEXEC) does this atomically! */

    close(pfd[0]); close(pfd[1]);
    close(pfd2[0]); close(pfd2[1]);
    return 0;
}
/* Output:
   Created pipe: fd[0]=3, fd[1]=4
   fd[0] FD_CLOEXEC set: YES
   fd[1] FD_CLOEXEC set: YES
*/

By default, pipes block: read() on an empty pipe waits, write() on a full pipe waits. With O_NONBLOCK, these operations fail immediately with errno = EAGAIN instead of blocking.

Example 2: Nonblocking pipe with pipe2()

/* nonblocking_pipe.c */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

int main(void)
{
    int pfd[2];

    /* Create nonblocking pipe */
    if (pipe2(pfd, O_NONBLOCK) == -1) {
        perror("pipe2");
        return 1;
    }

    printf("=== Test 1: Nonblocking read on empty pipe ===\n");
    char buf[64];
    ssize_t n = read(pfd[0], buf, sizeof(buf));
    if (n == -1) {
        if (errno == EAGAIN)
            printf("read() returned EAGAIN (no data yet) — nonblocking works!\n");
        else
            perror("read");
    }

    printf("\n=== Test 2: Write data, then read ===\n");
    const char *msg = "Nonblocking pipe test";
    write(pfd[1], msg, strlen(msg));
    n = read(pfd[0], buf, sizeof(buf) - 1);
    buf[n] = '\0';
    printf("Read after write: \"%s\"\n", buf);

    printf("\n=== Test 3: Fill the pipe to test write blocking ===\n");
    /* Fill up the pipe buffer to test O_NONBLOCK on write */
    int total = 0;
    char fill[4096];
    memset(fill, 'X', sizeof(fill));
    while (1) {
        n = write(pfd[1], fill, sizeof(fill));
        if (n == -1) {
            if (errno == EAGAIN) {
                printf("write() returned EAGAIN — pipe is full (%d bytes written)\n",
                       total);
                break;
            }
            perror("write");
            break;
        }
        total += n;
    }

    close(pfd[0]);
    close(pfd[1]);
    return 0;
}
/* Output:
   === Test 1: Nonblocking read on empty pipe ===
   read() returned EAGAIN (no data yet) — nonblocking works!

   === Test 2: Write data, then read ===
   Read after write: "Nonblocking pipe test"

   === Test 3: Fill the pipe to test write blocking ===
   write() returned EAGAIN — pipe is full (65536 bytes written)
*/

Example 3: Set O_NONBLOCK on existing pipe using fcntl()

/* set_nonblock_fcntl.c — when you can't use pipe2() */
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

/* Helper: make an fd nonblocking */
int set_nonblocking(int fd)
{
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1) return -1;
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

int main(void)
{
    int pfd[2];
    pipe(pfd);  /* regular pipe */

    /* Make both ends nonblocking */
    set_nonblocking(pfd[0]);
    set_nonblocking(pfd[1]);

    /* Test: read from empty nonblocking pipe */
    char buf[64];
    ssize_t n = read(pfd[0], buf, sizeof(buf));
    if (n == -1 && errno == EAGAIN)
        printf("EAGAIN — empty pipe, nonblocking set via fcntl\n");

    close(pfd[0]);
    close(pfd[1]);
    return 0;
}