C++实现TCP服务器STDOUT重定向至客户端的问题排查

乱码的核心是父进程未正确捕获子进程的STDOUT输出，服务器终端能显示是因为子进程直接输出到终端，但客户端收到的是未被正确捕获的无效数据或编码不匹配的内容。

核心思路是通过管道将子进程的输出导向父进程，父进程读取后统一编码再发送给客户端，避免子进程直接输出到终端。

以Python为例的修正代码 #

import subprocess
import socket

def handle_client(conn):
    while True:
        # 接收客户端命令
        cmd_bytes = conn.recv(1024)
        if not cmd_bytes:
            break
        cmd = cmd_bytes.decode('utf-8').strip()
        
        # 捕获命令的标准输出和错误输出
        result = subprocess.run(
            cmd,
            shell=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,  # 将错误输出合并到标准输出
            text=True,
            encoding='utf-8'
        )
        
        # 将结果编码后发送给客户端
        conn.sendall(result.stdout.encode('utf-8'))
    conn.close()

# 服务器初始化代码（示例）
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('0.0.0.0', 8080))
server_socket.listen(5)
while True:
    client_conn, addr = server_socket.accept()
    handle_client(client_conn)

以C语言为例的修正代码 #

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

void handle_client(int client_fd) {
    char cmd[1024];
    ssize_t recv_len;
    while ((recv_len = read(client_fd, cmd, sizeof(cmd)-1)) > 0) {
        cmd[recv_len] = '\0';
        int pipe_fd[2];
        
        // 创建管道用于捕获子进程输出
        if (pipe(pipe_fd) == -1) {
            perror("pipe failed");
            continue;
        }

        pid_t pid = fork();
        if (pid == 0) {
            // 子进程：重定向stdout和stderr到管道写端
            close(pipe_fd[0]);
            dup2(pipe_fd[1], STDOUT_FILENO);
            dup2(pipe_fd[1], STDERR_FILENO);
            close(pipe_fd[1]);
            
            // 执行命令
            execl("/bin/sh", "sh", "-c", cmd, NULL);
            exit(EXIT_FAILURE);
        } else if (pid > 0) {
            // 父进程：读取管道内容并发送给客户端
            close(pipe_fd[1]);
            char buffer[4096];
            ssize_t read_len;
            
            waitpid(pid, NULL, 0); // 等待子进程执行完成
            while ((read_len = read(pipe_fd[0], buffer, sizeof(buffer))) > 0) {
                write(client_fd, buffer, read_len);
            }
            close(pipe_fd[0]);
        } else {
            perror("fork failed");
            close(pipe_fd[0]);
            close(pipe_fd[1]);
        }
    }
    close(client_fd);
}

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(8080),
        .sin_addr.s_addr = INADDR_ANY
    };
    bind(server_fd, (struct sockaddr*)&addr, sizeof(addr));
    listen(server_fd, 5);
    
    while (1) {
        int client_fd = accept(server_fd, NULL, NULL);
        handle_client(client_fd);
    }
    close(server_fd);
    return 0;
}

• 禁止子进程直接输出到服务器终端：必须通过管道将输出传递给父进程，确保父进程能拿到完整的命令响应。
• 编码统一：服务器捕获输出后，需用UTF-8（或系统默认编码）转换为字节流发送，客户端接收后用相同编码解码。
• 合并错误输出：将stderr重定向到stdout，确保客户端能收到命令执行的所有反馈，避免遗漏错误信息。

内容的提问来源于stack exchange，提问作者Iman Abdollahzadeh