Linux TCP 服务器开发：从 Echo 到远程命令执行的并发与安全

echo 服务器核心流程：创建 socket → 绑定 IP 端口 → 监听 → 接受连接 → 读取数据 → 原样返回 → 关闭连接。

核心代码片段：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define SERVER_PORT 8080
#define BUF_SIZE 1024
int main() {
    // 1. 创建监听 socket
    int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_sock == -1) {
        perror("socket failed");
        return -1;
    }
    // 2. 初始化服务器地址（绑定 0.0.0.0:8080）
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    server_addr.sin_addr.s_addr = INADDR_ANY; // 等价于 0.0.0.0
    // 3. 绑定地址
    if (bind(listen_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind failed");
        close(listen_sock);
        return -1;
    }
    // 4. 监听（backlog 设为 5，允许 5 个半连接）
    if (listen(listen_sock, 5) == -1) {
        perror("listen failed");
        close(listen_sock);
        return -1;
    }
    printf("Echo server listening on 0.0.0.0:%d\n", SERVER_PORT);
    // 5. 接受连接并处理 echo
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    int conn_sock = accept(listen_sock, (struct sockaddr*)&client_addr, &client_addr_len);
    if (conn_sock == -1) {
        perror("accept failed");
        close(listen_sock);
        return -1;
    }
    printf("Client connected: %s:%d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    // 6. 读取客户端数据并原样返回
    char buf[BUF_SIZE];
    ssize_t n = read(conn_sock, buf, BUF_SIZE);
    if (n > 0) {
        write(conn_sock, buf, n); // 原样返回
    }
    // 7. 关闭连接
    close(conn_sock);
    close(listen_sock);
    return 0;
}

二、并发篇 1：多进程版本 echo 服务器

上面的基础版服务器有个致命问题 —— 只能处理一个客户端连接，处理完就退出了。要支持并发，首先想到用多进程：父进程负责接受连接，子进程负责处理业务。

2.1 多进程核心逻辑与代码

核心设计思路：

1. 父进程一直循环调用accept，拿到新的连接套接字conn_sock；
2. 每次拿到conn_sock后，fork()创建子进程；
3. 子进程不需要监听套接字listen_sock，要主动关闭（避免文件描述符泄漏）；
4. 子进程专注处理conn_sock的 echo 业务，处理完关闭conn_sock并退出。

优化后的多进程服务器核心代码（只改 accept 后的逻辑）：

// 替换基础版中 accept 后的代码
while (1) {
    // 父进程循环接受连接
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    int conn_sock = accept(listen_sock, (struct sockaddr*)&client_addr, &client_addr_len);
    if (conn_sock == -1) {
        perror("accept failed");
        continue;
    }
    printf("Client connected: %s:%d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    // 创建子进程处理业务
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        close(conn_sock);
        continue;
    } else if (pid == 0) {
        // 子进程
        close(listen_sock); // 子进程不需要监听套接字，关闭！
        // 处理 echo 业务
        char buf[BUF_SIZE];
        ssize_t n = read(conn_sock, buf, BUF_SIZE);
        if (n > 0) {
            write(conn_sock, buf, n);
        }
        close(conn_sock); // 子进程处理完关闭连接
        exit(0); // 子进程退出
    } else {
        // 父进程
        close(conn_sock); // 父进程不需要连接套接字，关闭！
    }
}

2.2 解决僵尸进程问题

多进程模型有个坑：子进程退出后，如果父进程不回收，会变成僵尸进程，占用系统资源。

方案 1：注册信号处理函数（推荐）

子进程退出时会给父进程发SIGCHLD信号，我们可以注册信号处理函数，用waitpid非阻塞回收子进程：

#include <signal.h>
#include <sys/wait.h>
// 信号处理函数：回收僵尸进程
void handle_sigchld(int sig) {
    // WNOHANG：非阻塞，有子进程退出就回收，没有就返回
    while (waitpid(-1, NULL, WNOHANG) > 0);
}
// 在 main 函数的 socket 创建后，注册信号
signal(SIGCHLD, handle_sigchld);

方案 2：创建孙子进程（孤儿进程）

核心逻辑：

1. 父进程 fork 出子进程；
2. 子进程再 fork 出孙子进程，然后子进程立即退出；
3. 孙子进程变成孤儿进程，由系统（init/systemd）接管，退出后自动回收；
4. 父进程不需要阻塞，也不用处理信号。

代码实现（修改 fork 部分）：

pid_t pid = fork();
if (pid == -1) {
    perror("fork failed");
    close(conn_sock);
    continue;
} else if (pid == 0) {
    // 子进程
    pid_t grand_pid = fork();
    if (grand_pid == -1) {
        exit(1);
    } else if (grand_pid == 0) {
        // 孙子进程
        close(listen_sock);
        // 处理 echo 业务
        char buf[BUF_SIZE];
        ssize_t n = read(conn_sock, buf, BUF_SIZE);
        if (n > 0) write(conn_sock, buf, n);
        close(conn_sock);
        exit(0);
    } else {
        // 子进程
        exit(0); // 子进程立即退出，孙子进程变成孤儿
    }
} else {
    // 父进程
    close(conn_sock); // 父进程不需要处理子进程退出，因为子进程已经退出了
}

2.3 多进程模型的小细节：获取客户端 IP

通过accept的第二个参数client_addr，可以轻松获取客户端的 IP 和端口：

// accept 后的代码
char client_ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, INET_ADDRSTRLEN);
uint16_t client_port = ntohs(client_addr.sin_port);
printf("Client connected: %s:%d\n", client_ip, client_port);

2.4 多进程模型的痛点

多进程虽然解决了并发问题，但缺点很明显：

• 进程创建和销毁的开销大；
• 每个进程占用独立的内存空间，连接数多了会导致服务器内存、CPU 压力剧增；
• 进程间通信复杂（如果需要共享数据）。

三、并发篇 2：多线程版本服务器

线程是轻量级进程，创建 / 销毁开销远小于进程，且线程间共享进程资源（如文件描述符、内存），适合高并发场景。

3.1 多线程核心逻辑与代码

核心思路：

1. 父进程（主线程）循环accept获取conn_sock；
2. 每次拿到conn_sock后，创建新线程处理业务；
3. 线程处理完业务后关闭conn_sock并退出。

核心代码（替换多进程的 fork 逻辑）：

#include <pthread.h>
// 线程处理函数（注意参数必须是 void*类型）
void* echo_handler(void* arg) {
    int conn_sock = *(int*)arg;
    free(arg); // 释放传参的内存
    // 分离线程：线程退出后自动释放资源，不需要 pthread_join
    pthread_detach(pthread_self());
    // 处理 echo 业务
    char buf[BUF_SIZE];
    ssize_t n = read(conn_sock, buf, BUF_SIZE);
    if (n > 0) {
        write(conn_sock, buf, n);
    }
    close(conn_sock);
    return NULL;
}
// accept 后的逻辑
while (1) {
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    int conn_sock = accept(listen_sock, (struct sockaddr*)&client_addr, &client_addr_len);
    if (conn_sock == -1) {
        perror("accept failed");
        continue;
    }
    // 为线程传参（不能直接传栈变量，要用堆）
    int* p_conn_sock = malloc(sizeof(int));
    *p_conn_sock = conn_sock;
    // 创建线程
    pthread_t tid;
    if (pthread_create(&tid, NULL, echo_handler, p_conn_sock) != 0) {
        perror("pthread_create failed");
        free(p_conn_sock);
        close(conn_sock);
    }
}

3.2 线程与文件描述符的两个关键问题

问题 1：进程打开的 FD，线程能看到吗？（答案：1）

文件描述符（FD）是进程级资源，所有线程共享同一个进程的 FD 表。比如主线程打开的listen_sock，所有子线程都能看到；子线程创建的conn_sock，主线程也能操作。

问题 2：线程敢不敢关闭自己不需要的 FD？（答案：敢，但要谨慎）

• 可以关闭：比如子线程不需要listen_sock，可以关闭，不影响主线程的listen_sock（FD 的引用计数减 1，只有引用计数为 0 时才真正关闭）；
• 谨慎点：不要关闭其他线程还在使用的 FD！比如主线程还在处理conn_sock，子线程如果关闭这个 FD，会导致主线程的 IO 操作失败。

3.3 短服务 vs 长服务

多线程模型适配不同的业务场景：

• 短服务：单次请求 - 响应就断开（如 echo 服务器），线程创建 / 销毁的开销可以接受；
• 长服务：连接保持，持续交互（如抢票、翻译服务），线程会长期存在，更能体现线程的优势。

四、并发篇 3：线程池版本服务器

多线程虽然比多进程高效，但如果连接数暴增（比如上万），频繁创建 / 销毁线程的开销依然很大。线程池就是提前创建一批线程，放在池子里，有连接就分配线程处理，处理完线程回到池子，避免频繁创建销毁。

4.1 线程池核心设计

线程池的核心是'任务队列 + 互斥锁 + 条件变量'：

1. 提前创建 N 个线程，线程启动后阻塞在条件变量上；
2. 主线程accept拿到conn_sock后，把conn_sock封装成任务，加入任务队列；
3. 发送条件变量信号，唤醒一个空闲线程处理任务；
4. 线程处理完任务后，回到阻塞状态，等待下一个任务。

4.2 线程池核心代码（简化版）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define THREAD_POOL_SIZE 4 // 线程池大小
#define BUF_SIZE 1024
#define SERVER_PORT 8080
// 任务结构体：存放连接套接字
typedef struct {
    int conn_sock;
} Task;
// 任务队列
Task task_queue[1024];
int queue_head = 0;
int queue_tail = 0;
// 同步机制
pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t queue_cond = PTHREAD_COND_INITIALIZER;
// 线程处理函数
void* thread_worker(void* arg) {
    while (1) {
        // 加锁
        pthread_mutex_lock(&queue_mutex);
        // 任务队列为空，阻塞等待
        while (queue_head == queue_tail) {
            pthread_cond_wait(&queue_cond, &queue_mutex);
        }
        // 取出任务
        Task task = task_queue[queue_head];
        queue_head = (queue_head + 1) % 1024;
        // 解锁
        pthread_mutex_unlock(&queue_mutex);
        // 处理 echo 业务
        char buf[BUF_SIZE];
        ssize_t n = read(task.conn_sock, buf, BUF_SIZE);
        if (n > 0) {
            write(task.conn_sock, buf, n);
        }
        close(task.conn_sock);
    }
    return NULL;
}
// 初始化线程池
void init_thread_pool() {
    pthread_t tid;
    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_create(&tid, NULL, thread_worker, NULL);
        pthread_detach(tid);
    }
}
// 添加任务到队列
void add_task(int conn_sock) {
    pthread_mutex_lock(&queue_mutex);
    // 放入任务队列
    task_queue[queue_tail].conn_sock = conn_sock;
    queue_tail = (queue_tail + 1) % 1024;
    // 发送信号唤醒线程
    pthread_cond_signal(&queue_cond);
    pthread_mutex_unlock(&queue_mutex);
}
int main() {
    // 初始化线程池
    init_thread_pool();
    // 创建监听 socket（和基础版一样）
    int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    server_addr.sin_addr.s_addr = INADDR_ANY;
    bind(listen_sock, (struct sockaddr*)&server_addr, sizeof(server_addr));
    listen(listen_sock, 5);
    // 主线程循环 accept
    while (1) {
        struct sockaddr_in client_addr;
        socklen_t client_addr_len = sizeof(client_addr);
        int conn_sock = accept(listen_sock, (struct sockaddr*)&client_addr, &client_addr_len);
        if (conn_sock == -1)
            continue;
        // 添加任务到线程池
        add_task(conn_sock);
    }
    close(listen_sock);
    return 0;
}

线程池的优势在于'解耦'：

• 主线程只负责'接连接'，不处理业务；
• 线程池只负责'处理业务'，不用关心连接怎么来；
• 上层业务逻辑（比如把 echo 改成翻译、抢票）只需要修改thread_worker里的处理逻辑即可，不用动底层的连接逻辑。

五、扩展篇：远程命令执行服务器（附安全防护）

把 echo 的逻辑改成'客户端发命令，服务器执行并返回结果'，是很常见的后端需求，但这里有巨大的安全风险，必须做防护。

5.1 远程命令执行核心逻辑

核心思路：客户端发送命令字符串（如ls、pwd），服务器用popen执行命令，读取执行结果并返回给客户端。

核心代码（替换线程池的 echo 处理逻辑）：

// 替换 thread_worker 里的 echo 逻辑
char buf[BUF_SIZE];
ssize_t n = read(task.conn_sock, buf, BUF_SIZE);
if (n > 0) {
    buf[n-1] = '\0'; // 去掉换行符
    // 执行命令并读取结果
    FILE* fp = popen(buf, "r");
    if (fp == NULL) {
        const char* err = "Command execute failed\n";
        write(task.conn_sock, err, strlen(err));
        close(task.conn_sock);
        continue;
    }
    // 读取命令执行结果并返回
    char result[BUF_SIZE];
    while (fgets(result, BUF_SIZE, fp) != NULL) {
        write(task.conn_sock, result, strlen(result));
    }
    pclose(fp);
}
close(task.conn_sock);

5.2 安全防护：白名单机制

如果直接执行客户端发来的命令，风险极大 —— 比如客户端发rm -rf /，服务器直接玩完。所以必须做白名单：只允许执行指定的安全命令。

5.3 白名单核心代码

// 定义白名单命令
const char* whitelist[] = {"ls", "pwd", "date", "whoami", NULL};
// 检查命令是否在白名单中
int is_in_whitelist(const char* cmd) {
    for (int i = 0; whitelist[i] != NULL; i++) {
        if (strcmp(cmd, whitelist[i]) == 0) {
            return 1;
        }
    }
    return 0;
}
// 在执行命令前加检查
if (n > 0) {
    buf[n-1] = '\0';
    // 检查白名单
    if (!is_in_whitelist(buf)) {
        const char* err = "Error: Command not allowed\n";
        write(task.conn_sock, err, strlen(err));
        close(task.conn_sock);
        continue;
    }
    // 执行白名单内的命令
    FILE* fp = popen(buf, "r");
    // ... 后续逻辑不变
}

六、总结

本文从基础的 echo 服务器出发，一步步优化并发能力（多进程→多线程→线程池），最后扩展到远程命令执行并补充安全防护，核心知识点总结：

1. 基础 socket 编程：服务器bind+listen+accept，客户端connect，注意 FD 的管理；
2. 并发优化：多进程解决基础并发但开销大，多线程轻量化但需注意 FD 共享，线程池是高并发最优解；
3. 安全防护：远程命令执行必须加白名单，限制可执行的命令范围，避免恶意攻击。

最后补充两个实战小技巧：

• 调试时用netstat -anp | grep 端口查看端口监听状态，确认服务器是否正常启动；
• 用ps -ef | grep 进程名查看进程 / 线程状态，排查僵尸进程、线程泄漏问题。