Linux C语言Socket编程入门：从TCP通信到Echo服务器实战

1. 项目概述：为什么从Socket通信开始？

如果你刚开始接触Linux下的C语言网络编程，或者想彻底搞懂网络通信的底层是怎么回事，那么从Socket编程入手，绝对是一个最直接、也最有效的选择。这就像学开车，你得先摸方向盘，而不是先去研究发动机的燃烧原理。Socket通信，就是网络编程里的那个“方向盘”。它不是什么高深莫测的黑科技，而是操作系统提供给你的一套标准接口，让你写的程序能和网络上的另一台机器“说上话”。

我见过很多新手，一上来就被各种网络协议、三次握手、滑动窗口这些概念吓住了。其实，完全不必。Socket编程的精髓在于“用”，你先把它用起来，看到数据在两个程序之间流动起来，那种成就感会立刻驱散你的恐惧。无论是你想写一个简单的聊天程序、一个文件传输工具，还是为更复杂的服务器程序打基础，Socket都是你必须跨过的第一道坎。在Linux环境下用C语言来实现，更是能让你接触到最纯粹、最接近系统内核的编程体验，这对于理解整个计算机网络栈的工作机制，有着不可替代的价值。

2. 核心概念与模型解析

2.1 Socket到底是什么？

你可以把Socket想象成你家房子上的一个“网络插座”。你的电脑（主机）上有很多这样的“插座”，每个插座都有一个唯一的编号（地址+端口号）。当你想和远方的朋友（另一台主机）通信时，你就需要一根“网线”（网络连接）插到你的插座上，而网线的另一端，则插在你朋友家对应的插座上。

在技术层面，Socket是操作系统内核提供的一个抽象层，它封装了底层复杂的网络协议（如TCP/IP）操作。应用程序通过调用Socket API（一套函数），就能创建、连接、发送和接收数据，而无需关心数据包是如何在网卡上变成电信号发出去的。在Linux中，一切皆文件，Socket也被视为一种特殊的文件描述符（File Descriptor），你可以用read、write（或专用的send、recv）来操作它，这大大简化了编程模型。

2.2 TCP vs UDP：两种核心通信模型的选择

这是Socket编程的第一个关键决策点，选错了协议，你的程序行为可能会和预期大相径庭。

TCP（传输控制协议）：像打电话。建立连接需要“拨号”（三次握手），通话过程中双方确认“喂，你能听到吗？”（ACK确认），保证你说的每一句话对方都按顺序听到，最后结束通话要说“再见”（四次挥手）。它的特点是：

• 面向连接：通信前必须先建立稳定连接。
• 可靠传输：保证数据不丢失、不重复、按序到达。
• 流式数据：数据像水流一样，没有明确的边界。你发送了10字节，对方可能一次收到10字节，也可能先收到5字节再收到5字节。
• 适用场景：网页浏览（HTTP/HTTPS）、邮件（SMTP/POP3）、文件传输（FTP）、需要可靠性的任何应用。

UDP（用户数据报协议）：像发短信或寄明信片。你写好内容，填上地址（目标IP和端口），就发出去了。不关心对方是否收到，也不保证按顺序到达。它的特点是：

• 无连接：无需建立连接，直接发送。
• 不可靠传输：可能丢失、重复、乱序。
• 数据报边界：每个发送的数据包都是独立的，有明确边界。你发送一个100字节的报文，对方要么收到完整的100字节，要么完全收不到。
• 适用场景：视频直播、语音通话（容忍少量丢失，追求低延迟）、DNS查询、广播/多播。

注意：对于初学者，我强烈建议从TCP Socket开始。因为它能帮你建立起“连接”的概念，并且其可靠性能让你更专注于业务逻辑，而不是处理数据丢失的麻烦。本文后续的示例也将以TCP为主。

2.3 核心工作流程：客户端与服务器的角色

一次典型的TCP Socket通信，就像一次客户去银行柜台办理业务：

1. 服务器端（银行）：

   • 创建Socket（盖好银行大楼）：调用socket()函数，创建一个监听套接字。
   • 绑定地址（给银行挂上门牌号）：调用bind()函数，将这个Socket绑定到一个具体的IP地址和端口号（如0.0.0.0:8080）。
   • 开始监听（打开营业窗口，等待客户）：调用listen()函数，告诉操作系统这个Socket准备接受客户端的连接请求。
   • 接受连接（柜员接待客户）：调用accept()函数。这个函数是阻塞的——它会一直等待，直到有客户端连接进来，然后返回一个新的Socket用于和这个特定客户端通信。原来的监听Socket继续等待其他客户。

2. 客户端（顾客）：

   • 创建Socket（出门）：同样调用socket()创建套接字。
   • 发起连接（找到银行地址并走进去）：调用connect()函数，指定服务器的IP和端口，发起连接请求。

3. 数据传输（办理业务）：

   • 连接建立后，服务器用accept()返回的新Socket，客户端用它的Socket，双方就可以使用send()/write()和recv()/read()函数来收发数据。

4. 关闭连接（业务办完，离开）：

   • 通信完毕，双方调用close()关闭各自的Socket。

3. 环境准备与基础代码框架

3.1 开发环境搭建

你只需要一个安装了GCC编译器的Linux终端。绝大多数Linux发行版都默认安装了。可以通过命令检查：

gcc --version

如果没有，使用包管理器安装，例如在Ubuntu/Debian上：

sudo apt update && sudo apt install gcc

一个顺手的文本编辑器（如Vim, VSCode, Sublime Text）就足够了。我个人的习惯是在终端里用Vim直接写，编译调试一气呵成。

3.2 必要的头文件

在C文件的开头，你需要包含以下头文件，它们提供了Socket编程所需的所有数据类型和函数声明：

#include <stdio.h> // 标准输入输出，如printf #include <stdlib.h> // 标准库，如exit() #include <string.h> // 字符串操作，如strlen, memset #include <unistd.h> // Unix标准函数，如read, write, close #include <sys/types.h> // 数据类型定义，如pid_t #include <sys/socket.h> // Socket核心函数和数据结构（最核心！） #include <netinet/in.h> // Internet地址族结构，如sockaddr_in, htons, htonl #include <arpa/inet.h> // 地址转换函数，如inet_pton, inet_ntop

sys/socket.h和netinet/in.h是重中之重。

3.3 一个最简化的TCP服务器框架

我们先抛开错误处理，看看一个TCP服务器的主干代码长什么样，建立直观印象：

int main() { // 1. 创建Socket int server_fd = socket(AF_INET, SOCK_STREAM, 0); // 2. 准备地址结构 struct sockaddr_in server_addr; memset(&server_addr, 0, sizeof(server_addr)); // 清空结构体 server_addr.sin_family = AF_INET; // 使用IPv4 server_addr.sin_addr.s_addr = INADDR_ANY; // 监听所有网卡 server_addr.sin_port = htons(8080); // 监听8080端口 // 3. 绑定Socket与地址 bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)); // 4. 开始监听 listen(server_fd, 5); // 第二个参数是等待连接队列的最大长度 printf("Server listening on port 8080...\n"); // 5. 接受客户端连接 struct sockaddr_in client_addr; socklen_t client_len = sizeof(client_addr); int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len); printf("Client connected!\n"); // 6. 与客户端通信 (这里可以循环收发数据) char buffer[1024] = {0}; read(client_fd, buffer, 1024); // 读取客户端发来的数据 printf("Received: %s\n", buffer); char *reply = "Hello from server!"; write(client_fd, reply, strlen(reply)); // 发送回复 // 7. 关闭连接 close(client_fd); close(server_fd); return 0; }

3.4 一个最简化的TCP客户端框架

对应的客户端主干代码：

int main() { // 1. 创建Socket int sockfd = socket(AF_INET, SOCK_STREAM, 0); // 2. 准备服务器地址 struct sockaddr_in server_addr; memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_port = htons(8080); // 将点分十进制的IP地址转换为二进制格式 inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr); // 3. 连接服务器 connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)); printf("Connected to server!\n"); // 4. 发送数据 char *message = "Hello from client!"; write(sockfd, message, strlen(message)); // 5. 接收回复 char buffer[1024] = {0}; read(sockfd, buffer, 1024); printf("Server replied: %s\n", buffer); // 6. 关闭连接 close(sockfd); return 0; }

4. 核心函数与数据结构深度剖析

现在，我们来逐一拆解上面框架中用到的每一个关键部分。

4.1socket()：创建通信端点

int socket(int domain, int type, int protocol);

• 作用：向内核申请一个通信端点，返回一个文件描述符（fd）。
• 参数解析：
  • domain（协议族）：指定通信发生的“域”。
    • AF_INET：IPv4网络协议，这是我们最常用的。
    • AF_INET6：IPv6。
    • AF_UNIX或AF_LOCAL：同一台主机上的进程间通信。
  • type（套接字类型）：指定通信语义。
    • SOCK_STREAM：提供面向连接的、可靠的、双向的字节流。对应TCP。
    • SOCK_DGRAM：提供无连接的、不可靠的数据报服务。对应UDP。
  • protocol：通常填0，让系统根据前两个参数自动选择正确的协议（如SOCK_STREAM默认选TCP）。
• 返回值：成功返回一个非负整数（文件描述符），失败返回-1。

4.2sockaddr_in：地址的“容器”

网络通信必须知道“跟谁通信”，这就需要地址信息。sockaddr_in是用于IPv4的地址结构体。

struct sockaddr_in { sa_family_t sin_family; // 地址族，必须为AF_INET in_port_t sin_port; // 16位端口号 struct in_addr sin_addr; // 32位IPv4地址 char sin_zero[8]; // 填充字段，使结构体大小与sockaddr一致 }; struct in_addr { in_addr_t s_addr; // 32位IPv4地址（网络字节序） };

关键点：

1. 字节序问题：计算机存储数据有“大端”和“小端”之分，而网络传输统一使用“大端字节序”（网络字节序）。因此，在给sin_port和sin_addr.s_addr赋值时，必须将主机字节序转换为网络字节序。
2. 转换函数：
   • htons()：Host TO Network Short， 转换端口（16位）。
   • htonl()：Host TO Network Long， 转换IP地址（32位）。
   • 对应的有ntohs()和ntohl()用于从网络字节序转回主机字节序。
3. 地址赋值：
   • 指定特定IP：inet_pton(AF_INET, “192.168.1.100”, &server_addr.sin_addr)。
   • 监听所有接口：server_addr.sin_addr.s_addr = INADDR_ANY。这是服务器程序的常见做法。

4.3bind()：为Socket命名

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

• 作用：将一个Socket（由sockfd指定）与一个特定的IP地址和端口号（由addr指定）绑定起来。对于服务器来说，这是告诉操作系统：“我就在这个地址上提供服务”。
• 常见错误：
  • “Address already in use”：端口被占用。通常是因为之前的程序关闭后，端口处于TIME_WAIT状态。可以设置Socket选项SO_REUSEADDR来避免。
  • “Permission denied”：在Linux上，绑定1024以下的端口（如80，443）需要root权限。

4.4listen()：进入监听状态

int listen(int sockfd, int backlog);

• 作用：将主动套接字（用于connect）转换为被动套接字（用于accept），并开始监听连接请求。
• backlog参数：指定内核为此套接字维护的未完成连接队列和已完成连接队列的总和的最大长度。这个值不宜过大，通常设为5到10。如果队列满了，新的连接请求会被忽略，客户端会收到ECONNREFUSED错误。

4.5accept()：接受连接

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

• 作用：从已完成连接队列中取出第一个连接，创建一个全新的Socket，并返回其文件描述符。这个新Socket用于与这个特定的客户端通信。
• 阻塞特性：如果已完成连接队列为空，accept()会阻塞，直到有新的连接到来。
• 参数addr和addrlen：用于获取连接对方的地址信息（客户端的IP和端口）。如果不需要，可以传入NULL。

4.6connect()：发起连接

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

• 作用：客户端调用此函数，主动向addr指定的服务器地址发起连接请求。
• 过程：内核会触发TCP三次握手。此函数会阻塞，直到握手成功或失败。

4.7send()/recv()与write()/read()：数据传输

连接建立后，就可以收发数据了。

• send()和recv()：是专门为Socket设计的函数，比write/read多一个flags参数，可以控制一些特殊行为（如MSG_OOB发送带外数据）。

  ssize_t send(int sockfd, const void *buf, size_t len, int flags); ssize_t recv(int sockfd, void *buf, size_t len, int flags);

• write()和read()：是通用的文件I/O函数。因为Socket也是文件描述符，所以它们完全适用。对于简单的TCP流通信，用它们就足够了。

  ssize_t write(int fd, const void *buf, size_t count); ssize_t read(int fd, void *buf, size_t count);

实操心得：在TCP流式传输中，read/recv返回的字节数可能小于你请求的字节数。绝对不能假设一次read就能拿到全部数据！你必须在一个循环中反复读取，直到累积收到预期的数据量，或者遇到对方关闭连接（read返回0）。这是新手最容易出错的地方之一。

4.8close()：关闭连接

int close(int fd);

• 作用：关闭一个文件描述符。对于Socket，这会触发TCP连接关闭的四次挥手过程。
• 注意：关闭只是将文件描述符的引用计数减一。只有当所有引用该Socket的描述符都被关闭后，连接才会真正终止。

5. 完整可运行的TCP Echo服务器/客户端实现

理论说再多，不如跑一遍代码。下面是一个经典的“回声服务器”示例：客户端发送什么，服务器就原样发回什么。

5.1 服务器端代码 (tcp_echo_server.c)

这个版本加入了完整的错误处理和循环处理多个客户端请求的能力（但仍是串行处理，一个接一个）。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #define PORT 8080 #define BUFFER_SIZE 1024 void handle_client(int client_fd) { char buffer[BUFFER_SIZE]; ssize_t bytes_read; // 循环读取客户端数据并回显 while ((bytes_read = read(client_fd, buffer, BUFFER_SIZE - 1)) > 0) { buffer[bytes_read] = '\0'; // 确保字符串结束 printf("Received from client: %s\n", buffer); // 将收到的数据原样发回给客户端 if (write(client_fd, buffer, bytes_read) != bytes_read) { perror("write failed"); break; } printf("Echoed back to client.\n"); } if (bytes_read == 0) { printf("Client disconnected.\n"); } else if (bytes_read < 0) { perror("read failed"); } close(client_fd); } int main() { int server_fd, client_fd; struct sockaddr_in server_addr, client_addr; socklen_t client_len = sizeof(client_addr); // 1. 创建Socket server_fd = socket(AF_INET, SOCK_STREAM, 0); if (server_fd < 0) { perror("socket creation failed"); exit(EXIT_FAILURE); } // 2. 设置SO_REUSEADDR选项，避免“Address already in use”错误 int opt = 1; if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) { perror("setsockopt failed"); close(server_fd); exit(EXIT_FAILURE); } // 3. 配置服务器地址 memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = INADDR_ANY; // 监听所有接口 server_addr.sin_port = htons(PORT); // 4. 绑定地址 if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) { perror("bind failed"); close(server_fd); exit(EXIT_FAILURE); } // 5. 开始监听 if (listen(server_fd, 5) < 0) { perror("listen failed"); close(server_fd); exit(EXIT_FAILURE); } printf("TCP Echo Server is listening on port %d...\n", PORT); // 6. 主循环：接受并处理客户端连接 while (1) { client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len); if (client_fd < 0) { perror("accept failed"); continue; // 接受失败，继续等待下一个连接 } // 打印客户端连接信息 char client_ip[INET_ADDRSTRLEN]; inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, INET_ADDRSTRLEN); printf("New connection from %s:%d\n", client_ip, ntohs(client_addr.sin_port)); // 处理这个客户端的请求 handle_client(client_fd); } // 理论上循环不会退出，这里close用于程序被终止时清理 close(server_fd); return 0; }

5.2 客户端代码 (tcp_echo_client.c)

这个客户端允许用户从终端输入文本，发送给服务器并显示回显。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <netdb.h> // 用于gethostbyname，支持域名解析 #define SERVER_PORT 8080 #define BUFFER_SIZE 1024 int main(int argc, char *argv[]) { int sockfd; struct sockaddr_in server_addr; struct hostent *server; char buffer[BUFFER_SIZE]; char *server_hostname; if (argc < 2) { fprintf(stderr, "Usage: %s <server_ip_or_hostname>\n", argv[0]); exit(EXIT_FAILURE); } server_hostname = argv[1]; // 1. 创建Socket sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { perror("socket creation failed"); exit(EXIT_FAILURE); } // 2. 解析服务器地址（支持域名） server = gethostbyname(server_hostname); if (server == NULL) { fprintf(stderr, "Error: No such host '%s'\n", server_hostname); close(sockfd); exit(EXIT_FAILURE); } // 3. 配置服务器地址结构 memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; // 将主机名解析得到的地址列表复制到server_addr.sin_addr memcpy(&server_addr.sin_addr.s_addr, server->h_addr, server->h_length); server_addr.sin_port = htons(SERVER_PORT); // 4. 连接服务器 if (connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) { perror("connection failed"); close(sockfd); exit(EXIT_FAILURE); } printf("Connected to echo server at %s:%d\n", server_hostname, SERVER_PORT); printf("Type your message (type 'quit' to exit):\n"); // 5. 循环：读取用户输入，发送，接收回显 while (1) { printf("> "); fflush(stdout); // 确保提示符先显示 // 从标准输入读取一行 if (fgets(buffer, BUFFER_SIZE, stdin) == NULL) { break; // 读到EOF (Ctrl+D) } // 去掉末尾的换行符 buffer[strcspn(buffer, "\n")] = 0; // 检查退出命令 if (strcmp(buffer, "quit") == 0) { printf("Quitting...\n"); break; } // 发送数据到服务器 ssize_t bytes_sent = send(sockfd, buffer, strlen(buffer), 0); if (bytes_sent < 0) { perror("send failed"); break; } // 接收服务器的回显 ssize_t bytes_received = recv(sockfd, buffer, BUFFER_SIZE - 1, 0); if (bytes_received < 0) { perror("recv failed"); break; } else if (bytes_received == 0) { printf("Server closed the connection.\n"); break; } buffer[bytes_received] = '\0'; // 确保字符串结束 printf("Echo from server: %s\n", buffer); } // 6. 关闭连接 close(sockfd); printf("Connection closed.\n"); return 0; }

5.3 编译与运行

1. 编译：打开终端，进入代码所在目录。

   gcc -o tcp_echo_server tcp_echo_server.c gcc -o tcp_echo_client tcp_echo_client.c

2. 运行服务器：

   ./tcp_echo_server

   你会看到输出：TCP Echo Server is listening on port 8080...

3. 运行客户端（打开另一个终端）：

   ./tcp_echo_client 127.0.0.1

   如果服务器运行在同一台机器上，就用127.0.0.1（本地回环地址）。如果服务器在另一台机器上，换成那台机器的IP地址。 连接成功后，输入任意文本，你会看到服务器将其原样返回。

6. 进阶话题与性能考量

上面的例子是一个简单的串行服务器，一次只能服务一个客户端。在实际应用中，这远远不够。我们需要让服务器能同时处理多个客户端。

6.1 多进程与多线程模型

最直观的想法是为每个新连接创建一个新的进程或线程。

• 多进程：在accept之后，调用fork()创建子进程。子进程处理客户端请求，父进程继续accept。优点是进程间隔离性好，一个客户端崩溃不影响服务器主进程；缺点是创建进程开销大，进程间通信复杂。
• 多线程：在accept之后，创建新线程（使用pthread_create）来处理客户端。优点是创建开销比进程小，共享数据方便；缺点是编程复杂（需要处理线程同步），一个线程崩溃可能影响整个进程。

多线程服务器代码片段示例：

// ... (前面的socket, bind, listen代码不变) while (1) { client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len); pthread_t thread_id; int *p_client_fd = malloc(sizeof(int)); *p_client_fd = client_fd; // 必须传递堆上内存的地址 pthread_create(&thread_id, NULL, handle_client_thread, (void*)p_client_fd); pthread_detach(thread_id); // 分离线程，使其结束后自动释放资源 } // 线程处理函数 void* handle_client_thread(void* arg) { int client_fd = *((int*)arg); free(arg); // 释放动态分配的内存 // ... 处理客户端通信的逻辑（同之前的handle_client） close(client_fd); return NULL; }

6.2 I/O多路复用：select, poll, epoll

为每个连接创建一个线程/进程，当连接数成千上万时，资源消耗巨大。I/O多路复用技术允许一个进程同时监视多个文件描述符（Socket），当其中任何一个就绪（可读、可写、出错）时，就通知程序进行处理。这是构建高性能网络服务器的基石。

• select：最古老、跨平台性最好。但有以下缺点：
  • 监视的文件描述符数量有上限（通常是1024）。
  • 每次调用都需要将整个文件描述符集合从用户态拷贝到内核态。
  • 返回后需要遍历整个集合来找出就绪的描述符，效率低。
• poll：解决了select描述符数量限制的问题（使用链表存储），但拷贝和遍历的问题依然存在。
• epoll（Linux特有）：Linux下高性能网络编程的首选。
  • 边缘触发（ET）与水平触发（LT）：这是epoll的核心概念。水平触发是默认模式，只要文件描述符就绪（比如读缓冲区有数据），就会一直通知你。边缘触发则只在状态变化时通知一次（比如从无数据到有数据）。ET模式效率更高，但编程更复杂，必须一次性把缓冲区数据读完。
  • 工作流程：
    1. epoll_create：创建一个epoll实例。
    2. epoll_ctl：向epoll实例中添加、修改或删除要监视的文件描述符及其关注的事件（可读、可写等）。
    3. epoll_wait：等待事件发生。返回就绪的事件列表，程序只需遍历这个很小的列表，效率极高。

一个简单的epoll服务器框架思路：

1. 将监听Socket（server_fd）添加到epoll实例，监听EPOLLIN（可读）事件。
2. 当epoll_wait返回并告知server_fd就绪时，调用accept接受新连接。
3. 将新接受的客户端Socket也添加到epoll实例，监听EPOLLIN事件（通常设置为边缘触发EPOLLET以提高性能）。
4. 当某个客户端Socket就绪时，在循环中一次性读取所有数据（对于ET模式至关重要）并进行处理。

6.3 非阻塞I/O与异步I/O

• 非阻塞I/O：通过fcntl设置Socket为O_NONBLOCK模式。在这种模式下，accept,read,write等调用不会阻塞，如果操作不能立即完成，会立即返回一个错误（通常是EAGAIN或EWOULDBLOCK），告诉你“请稍后再试”。非阻塞I/O通常与epoll等I/O多路复用结合使用，是实现高性能服务器的标准模式。
• 异步I/O（AIO）：由内核在I/O操作完成后主动通知应用程序。Linux原生AIO（io_submit等）比较复杂，在实际网络编程中不如epoll+非阻塞I/O的组合流行。

7. 常见问题、调试技巧与避坑指南

7.1 编译与运行常见错误

7.2 网络字节序与主机字节序

这是Socket编程中最经典的坑之一。记住一个原则：所有在网络中传输的多字节整数（端口号、IP地址），都必须使用网络字节序（大端）。

• 赋值时转换：server_addr.sin_port = htons(8080);server_addr.sin_addr.s_addr = inet_addr(“192.168.1.1”);(inet_addr返回的已是网络字节序)
• 读取时转换：int port = ntohs(client_addr.sin_port);

7.3 TCP粘包/拆包问题

由于TCP是流式协议，它不保证send/write的次数和recv/read的次数对应。比如：

• 客户端调用两次send(“Hello”)和send(“World”)。
• 服务器可能一次recv就收到“HelloWorld”（粘包）。
• 也可能第一次recv收到“He”，第二次收到“lloWorld”（拆包）。

解决方案是设计应用层协议：

1. 定长协议：每个消息长度固定。简单但不够灵活。
2. 分隔符协议：用特殊字符（如\n）作为消息边界。适用于文本协议。read时需要用循环直到读到分隔符。
3. 长度前缀协议（最常用）：在每个消息前面加上一个固定长度的字段，表示后面内容的长度。
   • 发送方：先计算消息体长度len，将len转换为网络字节序后发送，再发送消息体。
   • 接收方：先读取固定长度的长度字段，转换为主机字节序得到len，然后循环读取直到收满len字节的消息体。

7.4 资源管理与内存泄漏

• 文件描述符泄漏：每个Socket都是一个文件描述符。务必在不再需要时调用close()关闭它。在复杂的多进程/多线程程序中，要特别注意父子进程、线程间描述符的关闭时机。
• 动态内存管理：在多线程模型中，传递给线程的参数如果是在栈上分配的，在线程开始执行前就可能被释放了。必须使用堆内存（malloc）并在线程函数中负责释放。

7.5 使用netstat和tcpdump调试

• netstat -tulnp：查看当前系统上的TCP/UDP监听端口和连接状态。在调试“地址已被占用”或检查服务器是否成功监听时非常有用。
• tcpdump -i any port 8080 -nn：抓取经过本机8080端口的网络数据包。这是分析网络通信问题的终极利器，可以清晰地看到三次握手、数据传输、四次挥手的过程。

从最简单的单线程回声服务器，到支持并发的多线程模型，再到高性能的epoll+非阻塞I/O架构，Socket编程的世界层层深入。我建议你先将本文中的串行服务器和客户端代码吃透，运行起来，并尝试修改它（比如改变端口、发送不同的数据）。然后，可以挑战实现一个多线程的聊天服务器，让多个客户端可以连接并看到彼此的发言。在这个过程中，你会遇到各种问题，而解决这些问题的过程，正是你从“知道”到“理解”的关键一跃。网络编程的乐趣，就在于你写的代码能让机器在世界两端真正地“对话”。