C语言：如何将标准输入输出合并为单个双向文件描述符

Great question—this is a super common frustration when you've got APIs that expect a single bidirectional file descriptor (like what you'd get from a serial device or Unix socket) but you're stuck dealing with the separate, unidirectional stdin/stdout streams. The short answer is: it depends on whether stdin and stdout are connected to the same bidirectional device, but there are reliable workarounds for both cases.

Case 1: STDIN/STDOUT Point to the Same Bidirectional Device (e.g., a Terminal) #

If your stdin and stdout are both connected to a terminal (the most common interactive scenario), you're in luck! Terminal devices are inherently bidirectional, so you can just duplicate either stdin or stdout to get a single fd that supports both read and write operations.

Example in C:

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

int main() {
    // Duplicate stdin to get a bidirectional fd
    int bidir_fd = dup(STDIN_FILENO);
    if (bidir_fd == -1) {
        perror("dup failed");
        return 1;
    }

    // Now you can read from bidir_fd (like stdin) and write to it (like stdout)
    char buffer[256];
    ssize_t bytes_read = read(bidir_fd, buffer, sizeof(buffer)-1);
    if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
        write(bidir_fd, "You said: ", 9);
        write(bidir_fd, buffer, bytes_read);
    }

    close(bidir_fd);
    return 0;
}

This works because the underlying terminal device allows both read and write operations on any fd connected to it.

Case 2: STDIN/STDOUT Are Separate Unidirectional Streams (e.g., Pipes) #

If stdin and stdout are connected to separate pipes (or other unidirectional streams), you can't directly combine them into a single bidirectional fd. Instead, you'll need to use a socketpair to create a bidirectional communication channel, then spawn a child process to bridge the socket with stdin/stdout.

Here's how it works:

• Create a pair of bidirectional Unix domain sockets using socketpair().
• Fork a child process.
• In the child:
  • Bind one socket endpoint to both stdin and stdout using dup2().
  • Close the original socket fd (since we've duplicated it).
  • Run your target function that expects a bidirectional fd (or just handle I/O between the socket and stdin/stdout).
• In the parent:
  • Use the other socket endpoint as your bidirectional fd—any data written to it will be read by the child's stdin, and any data written by the child's stdout will be readable from this socket.

Example in C:

#include <unistd.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <string.h>

void target_function(int bidir_fd) {
    // This function expects a single bidirectional fd for read/write
    char buffer[256];
    ssize_t bytes_read = read(bidir_fd, buffer, sizeof(buffer)-1);
    if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
        dprintf(bidir_fd, "Echo: %s\n", buffer);
    }
}

int main() {
    int sock_pair[2];
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sock_pair) == -1) {
        perror("socketpair failed");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        close(sock_pair[0]);
        close(sock_pair[1]);
        return 1;
    }

    if (pid == 0) {
        // Child process: bridge socket to stdin/stdout
        close(sock_pair[0]);

        // Redirect stdin to the socket
        if (dup2(sock_pair[1], STDIN_FILENO) == -1) {
            perror("dup2 stdin failed");
            exit(1);
        }
        // Redirect stdout to the same socket
        if (dup2(sock_pair[1], STDOUT_FILENO) == -1) {
            perror("dup2 stdout failed");
            exit(1);
        }
        close(sock_pair[1]);

        // Run the function that expects a bidirectional fd
        target_function(STDIN_FILENO);
        exit(0);
    } else {
        // Parent process: use sock_pair[0] as the bidirectional fd
        close(sock_pair[1]);

        // Test writing to and reading from the bidirectional fd
        const char* test_msg = "Hello from parent!";
        write(sock_pair[0], test_msg, strlen(test_msg));

        char buffer[256];
        ssize_t bytes_read = read(sock_pair[0], buffer, sizeof(buffer)-1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("Parent received: %s\n", buffer);
        }

        wait(NULL);
        close(sock_pair[0]);
    }

    return 0;
}

Key Notes #

• The socketpair approach works for all scenarios, even when stdin/stdout are separate streams. It adds a small overhead of a child process, but it's the most reliable way to maintain interface consistency.
• Always remember to clean up file descriptors to avoid leaks—close any fds you don't need after duplication or forking.

内容的提问来源于stack exchange，提问作者Connor Lawson