基于fork()、execl()的Socket服务器执行awk命令异常排查

我来帮你分析下这个Socket通信+awk执行的问题，先理清楚核心痛点，再结合你提到的两段代码来拆解：

你遇到的问题本质是子进程的IO重定向、管道通信的生命周期管理以及Socket数据的读取边界处理没做好：

1. 最初把run_awk()放在循环里让同一进程多次调用，会导致之前的管道、文件描述符没有正确关闭，残留的输入被重复读取；
2. 把fork移到主函数后，子进程无法正确逐行读取输入，大概率是因为Socket的数据流是无边界的，你没有明确告诉子进程输入何时结束，或者awk没有接收到完整的输入就提前退出了。

第一段：run_awk()在循环中被同一进程多次调用的版本 #

// 假设的第一段代码结构
void run_awk(char *cmd, int client_fd) {
    int stdout_pipe[2], stderr_pipe[2];
    pipe(stdout_pipe);
    pipe(stderr_pipe);

    pid_t pid = fork();
    if (pid == 0) {
        // 重定向stdout到管道
        dup2(stdout_pipe[1], STDOUT_FILENO);
        dup2(stderr_pipe[1], STDERR_FILENO);
        close(stdout_pipe[0]);
        close(stderr_pipe[0]);
        // 读取客户端输入并传给awk？这里可能没处理好输入结束
        execl("/usr/bin/awk", "awk", cmd, NULL);
        exit(1);
    } else {
        close(stdout_pipe[1]);
        close(stderr_pipe[1]);
        // 读取管道内容返回给客户端
        char buf[1024];
        ssize_t n;
        // 处理stdout
        while ((n = read(stdout_pipe[0], buf, sizeof(buf))) > 0) {
            write(client_fd, buf, n);
        }
        // 处理stderr，加上ERRLINE标记
        int line_num = 1;
        while ((n = read(stderr_pipe[0], buf, sizeof(buf))) > 0) {
            // 拆分每行并添加ERRLINEi
            char err_buf[2048];
            snprintf(err_buf, sizeof(err_buf), "ERRLINE%d: %s", line_num++, buf);
            write(client_fd, err_buf, strlen(err_buf));
        }
        waitpid(pid, NULL, 0);
    }
}

// 主循环
int main() {
    // 初始化Socket等...
    while (1) {
        int client_fd = accept(server_fd, NULL, NULL);
        // 读取awk命令
        char cmd[256];
        read(client_fd, cmd, sizeof(cmd));
        // 这里直接循环调用run_awk？导致同一进程多次fork，管道没清理
        run_awk(cmd, client_fd);
        close(client_fd);
    }
}

问题点：

• 主循环中每次处理客户端请求时，run_awk()里的fork如果没有正确关闭所有未使用的管道描述符，会导致后续的子进程继承之前的管道，出现输入重复；
• 客户端的输入是多行，但代码里没有明确的输入结束标记，awk可能一直在等待输入，或者读取到残留的数据。

第二段：把fork移到主函数后的版本 #

// 假设的第二段代码结构
int main() {
    // 初始化Socket等...
    while (1) {
        int client_fd = accept(server_fd, NULL, NULL);
        pid_t pid = fork();
        if (pid == 0) {
            close(server_fd);
            // 读取awk命令
            char cmd[256];
            read(client_fd, cmd, sizeof(cmd));
            // 准备管道
            int stdout_pipe[2], stderr_pipe[2];
            pipe(stdout_pipe);
            pipe(stderr_pipe);

            pid_t awk_pid = fork();
            if (awk_pid == 0) {
                dup2(stdout_pipe[1], STDOUT_FILENO);
                dup2(stderr_pipe[1], STDERR_FILENO);
                close(stdout_pipe[0]);
                close(stderr_pipe[0]);
                close(client_fd);
                // 这里尝试逐行读取客户端输入？但Socket是流，无法直接按行分割
                char input_line[1024];
                while (read(client_fd, input_line, sizeof(input_line)) > 0) {
                    // 把输入传给awk？但awk是通过标准输入读取，这里应该重定向client_fd到stdin？
                    write(STDIN_FILENO, input_line, strlen(input_line));
                }
                execl("/usr/bin/awk", "awk", cmd, NULL);
                exit(1);
            } else {
                close(stdout_pipe[1]);
                close(stderr_pipe[1]);
                // 读取管道返回给客户端
                char buf[1024];
                ssize_t n;
                while ((n = read(stdout_pipe[0], buf, sizeof(buf))) > 0) {
                    write(client_fd, buf, n);
                }
                int line_num = 1;
                while ((n = read(stderr_pipe[0], buf, sizeof(buf))) > 0) {
                    char err_buf[2048];
                    snprintf(err_buf, sizeof(err_buf), "ERRLINE%d: %s", line_num++, buf);
                    write(client_fd, err_buf, strlen(err_buf));
                }
                waitpid(awk_pid, NULL, 0);
                close(client_fd);
                exit(0);
            }
        } else {
            close(client_fd);
            waitpid(pid, NULL, WNOHANG);
        }
    }
}

问题点：

• 子进程中尝试逐行读取客户端输入，但Socket是字节流，read()不一定能刚好读取一行，会导致输入分割错误；
• 在调用execl()之前手动把输入写给stdin是错误的，因为execl()会替换当前进程，之前的write操作根本不会被awk看到——正确的做法是直接把client_fd重定向到awk的stdin，而不是自己读取再转发；
• 没有处理客户端输入结束的情况，awk会一直等待输入，直到客户端关闭连接。

核心要解决的几个点：

1. 每个客户端请求对应一个独立的子进程，避免文件描述符混乱；
2. 把客户端Socket直接重定向到awk的stdin，让awk自己读取输入，不需要手动转发；
3. 正确管理管道的生命周期，关闭所有未使用的文件描述符；
4. 处理输入结束：客户端发送完输入后要关闭写端，或者约定一个结束标记（比如空行+EOF）。

以下是修复后的代码示例：

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

#define BUF_SIZE 1024

void handle_client(int client_fd) {
    // 第一步：读取awk命令（假设客户端先发送命令，以换行或NULL结尾）
    char cmd[256];
    ssize_t n = read(client_fd, cmd, sizeof(cmd)-1);
    if (n <= 0) {
        close(client_fd);
        return;
    }
    cmd[n] = '\0'; // 确保命令是字符串

    // 创建管道用于捕获stdout和stderr
    int stdout_pipe[2], stderr_pipe[2];
    if (pipe(stdout_pipe) == -1 || pipe(stderr_pipe) == -1) {
        perror("pipe failed");
        close(client_fd);
        return;
    }

    pid_t awk_pid = fork();
    if (awk_pid == -1) {
        perror("fork failed");
        close(stdout_pipe[0]); close(stdout_pipe[1]);
        close(stderr_pipe[0]); close(stderr_pipe[1]);
        close(client_fd);
        return;
    }

    if (awk_pid == 0) {
        // 子进程：执行awk
        // 重定向stdin到client_fd，stdout到管道，stderr到管道
        dup2(client_fd, STDIN_FILENO);
        dup2(stdout_pipe[1], STDOUT_FILENO);
        dup2(stderr_pipe[1], STDERR_FILENO);

        // 关闭所有不需要的文件描述符
        close(client_fd);
        close(stdout_pipe[0]); close(stdout_pipe[1]);
        close(stderr_pipe[0]); close(stderr_pipe[1]);

        // 执行awk命令
        execl("/usr/bin/awk", "awk", cmd, NULL);
        // 如果execl失败，退出
        perror("execl failed");
        exit(EXIT_FAILURE);
    } else {
        // 父进程：读取管道内容并返回给客户端
        close(stdout_pipe[1]);
        close(stderr_pipe[1]);

        // 读取stdout并发送给客户端
        char buf[BUF_SIZE];
        while ((n = read(stdout_pipe[0], buf, BUF_SIZE)) > 0) {
            write(client_fd, buf, n);
        }

        // 读取stderr，添加ERRLINE标记后发送
        int line_num = 1;
        char err_buf[BUF_SIZE + 20]; // 预留标记的空间
        while ((n = read(stderr_pipe[0], buf, BUF_SIZE)) > 0) {
            // 按行拆分stderr内容，避免标记混乱
            char *ptr = buf;
            char *newline;
            while ((newline = strchr(ptr, '\n')) != NULL) {
                *newline = '\0';
                snprintf(err_buf, sizeof(err_buf), "ERRLINE%d: %s\n", line_num++, ptr);
                write(client_fd, err_buf, strlen(err_buf));
                ptr = newline + 1;
            }
            // 处理最后一行没有换行的情况
            if (*ptr != '\0') {
                snprintf(err_buf, sizeof(err_buf), "ERRLINE%d: %s", line_num++, ptr);
                write(client_fd, err_buf, strlen(err_buf));
            }
        }

        // 等待awk进程结束
        waitpid(awk_pid, NULL, 0);

        // 关闭所有文件描述符
        close(stdout_pipe[0]);
        close(stderr_pipe[0]);
        close(client_fd);
    }
}

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(8080),
        .sin_addr.s_addr = INADDR_ANY
    };

    if (bind(server_fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    if (listen(server_fd, 5) == -1) {
        perror("listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port 8080...\n");

    while (1) {
        int client_fd = accept(server_fd, NULL, NULL);
        if (client_fd == -1) {
            perror("accept failed");
            continue;
        }

        // 每个客户端请求fork一个子进程处理
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork failed");
            close(client_fd);
            continue;
        }

        if (pid == 0) {
            close(server_fd); // 子进程不需要监听socket
            handle_client(client_fd);
            exit(EXIT_SUCCESS);
        } else {
            close(client_fd); // 父进程关闭客户端fd，由子进程处理
            waitpid(pid, NULL, WNOHANG); // 避免僵尸进程
        }
    }

    close(server_fd);
    return 0;
}

1. 客户端Socket重定向到awk的stdin：子进程中直接dup2(client_fd, STDIN_FILENO)，让awk从客户端Socket直接读取输入，不需要手动转发，避免了流分割错误；
2. 正确关闭管道描述符：每个进程都关闭自己不需要的管道端，比如父进程关闭管道写端，子进程关闭管道读端和原client_fd；
3. stderr的行处理：把读取到的stderr内容按行拆分，逐行添加ERRLINEi标记，避免标记和内容混乱；
4. 进程隔离：每个客户端请求对应一个独立的子进程，主进程只负责监听和fork，避免文件描述符冲突。

客户端需要先发送awk命令，然后发送多行输入，最后关闭写端（比如调用shutdown(fd, SHUT_WR)），这样awk才会知道输入结束，执行完命令退出。

内容的提问来源于stack exchange，提问作者Daniele Baieri