Understanding File Descriptors

In Unix-like operating systems, every open file, device, or socket is represented by a file descriptor. This descriptor is a non-negative integer used by the kernel to track open files within a process. While a single file may have multiple descriptors associated with it across different processes or within the same process, all subsequent I/O operations reference this integer identifier. In command-line shells, input and output redirection operators (< and >) manipulate these descriptors to route data streams.

Opening Files and Flags

To initiate file access, the open system call is utilized. There is also openat, which operates relative to a directory file descriptor, useful for avoiding race conditions in path resolution. The function signature requires specific access flags.

#include <fcntl.h>

int open(const char *pathname, int flags, ...);
int openat(int dirfd, const char *pathname, int flags, ...);

Among the flags, one of O_RDONLY, O_WRONLY, or O_RDWR must be specified. Optional flags modify behavior; for instance, O_CLOEXEC ensures the descriptor is closed automatically if the process executes a new program. This is functionally similar to setting the FD_CLOEXEC flag via fcntl after opening.

Managing File Offsets

The kernel maintains a current file offset for each open file description. The lseek function allows explicit manipulation of this offset.

#include <unistd.h>

off_t lseek(int fd, off_t offset, int whence);

Seeking beyond the end of the file does not immediately allocate disk space. However, if data is written after such a seek, a "hole" is created in the file. These holes read as null bytes (\0) but do not consume physical blocks until data is actually written. Consider a file containing "123". If a process seeks 2 bytes past the end and writes "abc", the resulting file structure includes implicit null bytes between the original content and the new data.

To retrieve the current file size or offset, one can seek to the end with an offset of zero:

off_t current_size = lseek(handle, 0, SEEK_END);

Atomicity in Operations

System calls like read and write are atomic regarding the call itself, though they may process fewer bytes than requested. File creation should also be atomic to prevent race conditions. Using open with the O_CREAT flag ensures that checking for existence and creating the file happens in a single kernel operation. Separating this into creat followed by open introduces a window where another process could interfere.

Duplicating file descriptors follows similar logic. The dup2 function is atomic, whereas manually closing a target descriptor and then duplicating via fcntl is not safe in multi-threaded or multi-process environments with out additional locking.

/* Atomic duplication */
dup2(source_fd, target_fd);

/* Non-atomic equivalent */
close(target_fd);
fcntl(source_fd, F_DUPFD, target_fd);

The fcntl Interface

The fcntl function serves as a versatile interface for manipulating file descriptor properties. It handles various commands depending on the required operation.

#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* arg */);

Key capabilities include:

• Duplication: F_DUPFD or F_DUPFD_CLOEXEC creates a copy of the descriptor.
• Descriptor Flags: F_GETFD and F_SETFD manage flags like FD_CLOEXEC.
• Status Flags: F_GETFL and F_SETFL manage access modes and status bits (e.g., O_APPEND, O_NONBLOCK). Note that F_SETFL cannot change the access mode (read/write).
• Ownership and Locks: Commands exist for asynchronuos I/O ownership and record locking.

Return values vary by command. Most return 0 on success, but duplication commands return the new descriptor number, and retrieval commands return the flag values. Errors are indicated by -1.

Descriptor Flags and Execution

The FD_CLOEXEC flag controls whether a file descriptor remains open across an exec call. If set, the descriptor closes automatically in the new program image. This is critical for security and resource management to prevent file leaks into spawned processes.

Below is a comprehensive example demonstrating descriptor duplication, flag inspection, and modification without relying on non-standard libraries.

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

#define HANDLE_ERROR(msg) do { perror(msg); exit(EXIT_FAILURE); } while(0)

void inspect_access_mode(int status) {
    switch (status & O_ACCMODE) {
        case O_RDONLY: printf("Read Only"); break;
        case O_WRONLY: printf("Write Only"); break;
        case O_RDWR:   printf("Read/Write"); break;
        default:       printf("Unknown Mode");
    }
}

void display_file_status(int fd) {
    int status = fcntl(fd, F_GETFL);
    if (status == -1) HANDLE_ERROR("F_GETFL failed");

    inspect_access_mode(status);
    if (status & O_APPEND)   printf(", Append");
    if (status & O_NONBLOCK) printf(", Non-blocking");
    if (status & O_SYNC)     printf(", Sync");
    printf("\n");
}

int enable_close_on_exec(int fd) {
    int flags = fcntl(fd, F_GETFD);
    if (flags == -1) HANDLE_ERROR("F_GETFD failed");
    
    flags |= FD_CLOEXEC;
    return fcntl(fd, F_SETFD, flags);
}

int duplicate_descriptor(int fd, int min_fd) {
    int new_fd = fcntl(fd, F_DUPFD, min_fd);
    if (new_fd == -1) HANDLE_ERROR("F_DUPFD failed");
    return new_fd;
}

int main(void) {
    int handle = open("test_data.txt", O_RDWR | O_CREAT, 0644);
    if (handle == -1) HANDLE_ERROR("Open failed");

    printf("Original FD: %d\n", handle);
    
    /* Duplicate to a specific minimum number */
    int copy = duplicate_descriptor(handle, 10);
    printf("Duplicated FD: %d\n", copy);

    /* Check initial flags */
    display_file_status(handle);

    /* Modify flags */
    enable_close_on_exec(handle);
    
    int fd_flags = fcntl(handle, F_GETFD);
    if (fd_flags & FD_CLOEXEC) {
        printf("FD_CLOEXEC is now set\n");
    }

    /* Write operation */
    const char *buffer = "system_programming";
    if (write(handle, buffer, strlen(buffer)) == -1) {
        HANDLE_ERROR("Write failed");
    }

    close(handle);
    close(copy);
    return 0;
}