C
Linux TCP 服务器开发：从 Echo 到远程命令执行的并发与安全
介绍 Linux 下 TCP 服务器开发流程。从基础 Socket 编程实现 Echo 服务器入手，逐步优化并发能力，涵盖多进程、多线程及线程池模型。重点讲解文件描述符管理、僵尸进程处理及线程同步机制。最后扩展至远程命令执行场景，通过白名单机制防范安全风险。适合后端开发者学习网络编程与高并发架构。
介绍 Linux 下 TCP 服务器开发流程。从基础 Socket 编程实现 Echo 服务器入手，逐步优化并发能力，涵盖多进程、多线程及线程池模型。重点讲解文件描述符管理、僵尸进程处理及线程同步机制。最后扩展至远程命令执行场景，通过白名单机制防范安全风险。适合后端开发者学习网络编程与高并发架构。
echo 服务器的核心逻辑很简单 —— 客户端发什么，服务器就返回什么。这一步我们先搞定基础的 socket 编程流程，以及开发中最容易踩的绑定、连接问题。
在编写服务器代码前，先理清两个高频问题：bind绑定和connect连接参数。
服务器端调用bind函数时，核心是绑定 IP 和端口：
0.0.0.0，表示监听服务器所有网卡的该端口，这是服务器的常规操作；192.168.1.100），则只监听该网卡的请求，适合多网卡的定向监听场景；客户端的connect函数核心是指定要连接的服务器信息：
struct sockaddr_in结构体，包含服务器 IP 和端口；bind本地端口，系统会自动分配一个未使用的端口，这是客户端和服务器的核心区别之一。给大家贴一段客户端connect的核心代码，一看就懂：
// 初始化服务器地址结构 struct sockaddr_in server_addr; memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_port = htons(8080); // 服务器端口 inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr); // 服务器IP // 连接服务器 int ret = connect(client_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)); if (ret == -1) { perror("connect failed"); close(client_sock); return -1; }
理清核心问题后，直接上 echo 客户端和服务器的核心代码，结合图片里的逻辑拆解。
echo 客户端核心流程：创建 socket → 连接服务器 → 发送数据 → 接收返回数据 → 关闭 socket。
核心代码片段：
#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_IP "127.0.0.1"
#define SERVER_PORT 8080
#define BUF_SIZE 1024
int main() {
// 1. 创建客户端 socket
int client_sock = socket(AF_INET, SOCK_STREAM, 0);
if (client_sock == -1) {
perror("socket failed");
return -1;
}
// 2. 初始化服务器地址
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);
inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr);
// 3. 连接服务器
if (connect(client_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
perror("connect failed");
close(client_sock);
return -1;
}
// 4. 发送数据并接收 echo
char buf[BUF_SIZE] = "Hello Echo Server!";
write(client_sock, buf, strlen(buf)); // 发送数据
memset(buf, 0, BUF_SIZE);
read(client_sock, buf, BUF_SIZE); // 接收返回数据
printf("Received from server: %s\n", buf);
// 5. 关闭 socket
close(client_sock);
return 0;
}
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;
}
上面的基础版服务器有个致命问题 —— 只能处理一个客户端连接，处理完就退出了。要支持并发，首先想到用多进程：父进程负责接受连接，子进程负责处理业务。
核心设计思路：
accept，拿到新的连接套接字conn_sock；conn_sock后，fork()创建子进程；listen_sock，要主动关闭（避免文件描述符泄漏）；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); // 父进程不需要连接套接字，关闭！
}
}
多进程模型有个坑：子进程退出后，如果父进程不回收，会变成僵尸进程，占用系统资源。
子进程退出时会给父进程发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);
核心逻辑：
代码实现（修改 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); // 父进程不需要处理子进程退出，因为子进程已经退出了
}
通过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);
多进程虽然解决了并发问题，但缺点很明显：
线程是轻量级进程，创建 / 销毁开销远小于进程，且线程间共享进程资源（如文件描述符、内存），适合高并发场景。
核心思路：
accept获取conn_sock；conn_sock后，创建新线程处理业务；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);
}
}
文件描述符（FD）是进程级资源，所有线程共享同一个进程的 FD 表。比如主线程打开的listen_sock，所有子线程都能看到；子线程创建的conn_sock，主线程也能操作。
listen_sock，可以关闭，不影响主线程的listen_sock（FD 的引用计数减 1，只有引用计数为 0 时才真正关闭）；conn_sock，子线程如果关闭这个 FD，会导致主线程的 IO 操作失败。多线程模型适配不同的业务场景：
多线程虽然比多进程高效，但如果连接数暴增（比如上万），频繁创建 / 销毁线程的开销依然很大。线程池就是提前创建一批线程，放在池子里，有连接就分配线程处理，处理完线程回到池子，避免频繁创建销毁。
线程池的核心是'任务队列 + 互斥锁 + 条件变量'：
accept拿到conn_sock后，把conn_sock封装成任务，加入任务队列；#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;
}
线程池的优势在于'解耦'：
thread_worker里的处理逻辑即可，不用动底层的连接逻辑。把 echo 的逻辑改成'客户端发命令，服务器执行并返回结果'，是很常见的后端需求，但这里有巨大的安全风险，必须做防护。
核心思路：客户端发送命令字符串（如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);
如果直接执行客户端发来的命令，风险极大 —— 比如客户端发rm -rf /，服务器直接玩完。所以必须做白名单：只允许执行指定的安全命令。
// 定义白名单命令
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 服务器出发，一步步优化并发能力（多进程→多线程→线程池），最后扩展到远程命令执行并补充安全防护，核心知识点总结：
bind+listen+accept，客户端connect，注意 FD 的管理；最后补充两个实战小技巧：
netstat -anp | grep 端口查看端口监听状态，确认服务器是否正常启动；ps -ef | grep 进程名查看进程 / 线程状态，排查僵尸进程、线程泄漏问题。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online