Using dup and dup2 for I/O Redirection in C

In the C programming language, the dup and dup2 system calls are fundamental POSIX functions used to duplicate open file descriptors. This article provides a focused explanation of how these system calls work, their internal mechanisms within the operating system's file descriptor table, and how they are practically applied to achieve standard input, output, and error redirection in programs such as command-line shells.

Understanding File Descriptors

Every running process maintains a file descriptor table managed by the kernel. By convention, the first three slots are reserved for standard streams:

• 0: Standard Input (stdin / STDIN_FILENO)
• 1: Standard Output (stdout / STDOUT_FILENO)
• 2: Standard Error (stderr / STDERR_FILENO)

System calls like read, write, and higher-level library functions like printf rely on these specific integer indices. Redirection works by pointing one of these fixed descriptors to a different file or pipeline.

The dup System Call

The dup function creates a copy of an existing file descriptor using the lowest-numbered unused descriptor available:

int dup(int oldfd);

When dup(oldfd) succeeds, it returns a new file descriptor that refers to the exact same open file description (sharing file offsets, status flags, and access modes) as oldfd.

To redirect standard output using dup, a program must manually close the target file descriptor first:

close(STDOUT_FILENO); // Free up file descriptor 1
dup(file_fd);         // The lowest available descriptor is now 1

While functional, this approach is non-atomic and can create race conditions in multi-threaded environments if another thread opens a file between the close and dup calls.

The dup2 System Call

The dup2 system call eliminates the need for manual closing and ensures an atomic operation:

int dup2(int oldfd, int newfd);

dup2 duplicates oldfd onto newfd. If newfd is already open, it is silently and atomically closed before being reassigned. If oldfd is invalid, the call fails and newfd is not closed. If oldfd equals newfd, dup2 simply returns newfd without doing anything.

Because of its explicit target assignment and atomicity, dup2 is the standard choice for I/O redirection.

Practical Implementation: Redirecting stdout to a File

The following example demonstrates redirecting standard output to a text file using dup2:

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

int main(void) {
    // 1. Open the target file
    int fd = open("output.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open failed");
        return 1;
    }

    // 2. Redirect stdout (1) to point to the file
    if (dup2(fd, STDOUT_FILENO) < 0) {
        perror("dup2 failed");
        close(fd);
        return 1;
    }

    // 3. Close the original file descriptor as it is no longer needed
    close(fd);

    // 4. Output goes to "output.txt" instead of the terminal
    printf("This message is written to the file instead of the console.\n");

    return 0;
}

Key Differences Summary