Linux网络编程核心：Socket、字节序与TCP/UDP实战解析

1. 从零开始理解 Linux 网络编程：Socket、字节序与地址转换

如果你刚开始接触 Linux 下的网络编程，看到一堆socket、bind、connect、htonl之类的函数，还有sockaddr_in这种结构体，可能会觉得头大。别担心，这种感觉我十几年前刚开始写网络程序时也有过。网络编程的本质，其实就是让不同机器（甚至是同一台机器上的不同进程）能相互“对话”。而socket（套接字）就是系统给我们准备好的“电话”。今天，我就从一个老码农的角度，带你拆解 Linux Internet Domain 应用编程的核心，把那些看似枯燥的概念，变成你手里实实在在能用的工具。我们会重点聊聊基于 TCP 的可靠“流”通信和基于 UDP 的“数据报”通信到底有什么区别，以及为什么我们总要操心“字节序”和“地址转换”这些看似底层的问题。

简单来说，Internet domain socket 就是网络通信的端点。它主要分两类：流 socket (SOCK_STREAM)和数据报 socket (SOCK_DGRAM)。流 socket 基于 TCP 协议，它像一条稳定的双向水管，数据像水流一样按顺序、可靠地传输，确保你发送的每一个字节都能完整、有序地到达对端，非常适合文件传输、网页浏览这类场景。而数据报 socket 基于 UDP 协议，它更像寄明信片，每张“明信片”（数据包）独立发送，可能丢失、重复或乱序，但开销小、速度快，常用于视频流、DNS 查询等对实时性要求高、允许少量丢包的场景。

理解这个基础分类，是写好网络程序的第一步。接下来，我们会深入每个环节，从网络字节序这个“绊脚石”开始，到如何优雅地处理主机名和服务名，最后手把手实现客户端和服务器。这篇文章适合有一定 C 语言基础，想系统学习 Linux 网络编程的开发者。我会尽量用代码和类比说清原理，并提供可以直接拿来用的示例和避坑指南。

2. 网络通信的基石：Socket 类型、字节序与数据表示

在动手写代码之前，我们必须打好理论基础。网络编程不是简单的函数调用，其背后是一整套约定和规则。理解这些规则，才能写出健壮、高效的网络程序。

2.1 流 Socket 与数据报 Socket 的深度辨析

很多人知道 TCP 可靠、UDP 不可靠，但背后的机制和影响才是关键。

TCP 流 Socket (SOCK_STREAM)的可靠性，是通过复杂的握手、确认、重传、排序和流量控制机制实现的。建立连接需要三次握手，断开需要四次挥手。数据被拆分成“段”传输，接收方会确认，丢失则重传。这意味着：

1. 面向连接：通信前必须先建立连接，这带来了开销，也保证了通道的独占性和状态性。
2. 字节流：没有消息边界。你发送了两次write(“hello”)和write(“world”)，对端可能一次read就收到 “helloworld”。应用层必须自己设计协议（如约定长度、使用分隔符）来区分消息。
3. 流量控制：通过滑动窗口机制，防止发送方淹没接收方。
4. 拥塞控制：根据网络状况动态调整发送速率，避免网络瘫痪。

UDP 数据报 Socket (SOCK_DGRAM)则简单粗暴得多。它无连接，每个数据包自带目标地址，独立路由。

1. 无连接：无需建立连接，直接发送。开销极小，延迟低。
2. 保留消息边界：你发送一个数据报，对端接收到的就是一个完整的数据报（当然，不能超过最大传输单元 MTU）。
3. 不保证可靠性：数据报可能因为网络拥堵、路由错误等原因丢失。也可能因为网络路径变化，后发的包先到（乱序）。甚至可能重复（网络设备重传导致）。
4. 无流量和拥塞控制：发送方可以以任何速率发送，可能压垮接收方或网络。

这里有一个关键区别，原文也提到了：UNIX domain 数据报 socket 是可靠的，而 Internet domain (UDP) 的则不是。这是因为 UNIX domain 的通信完全在内核中完成，数据直接从发送方的 socket 缓冲区拷贝到接收方的 socket 缓冲区，只要缓冲区不满，就不会丢。而网络 UDP 则要经历复杂的网络环境。所以，把本地进程间通信的 UNIX domain 程序简单地改成 UDP 网络通信，是灾难性的，必须自己处理丢包、乱序等问题。

2.2 网络字节序：为什么需要htonl和ntohl？

这是网络编程的第一个“坑”。不同的 CPU 架构（如 x86 和早期的 PowerPC）在内存中存储多字节整数（如short,int）的方式可能不同，这称为“字节序”。

• 大端序：高位字节存储在低内存地址。类似于我们书写数字“一千二百三十四”，总是先写千位“1”。
• 小端序：低位字节存储在低内存地址。类似于有些国家写日期，先写日子再写月份。

网络协议栈（TCP/IP）设计时，统一规定使用大端序作为网络字节序。这是为了确保不同架构的机器在网络中交换数据时，能有一致的解释。

假设一个uint32_t的值0x12345678在内存中的布局：

• 大端序（网络字节序）：地址增长方向12 34 56 78
• 小端序（主机字节序，x86常见）：地址增长方向78 56 34 12

如果你在小端机器上直接发送0x12345678，接收方是大端机器，它会将其解释为0x78563412，数据就完全错了。

因此，所有在网络中传输的多字节整数（如端口号、IP地址），在发送前必须用htonl(host to network long) 或htons(host to network short) 从主机字节序转换为网络字节序。接收后，再用ntohl、ntohs转换回来。

#include <arpa/inet.h> uint32_t htonl(uint32_t hostlong); // 32位整数，主机序 -> 网络序 uint16_t htons(uint16_t hostshort); // 16位整数，主机序 -> 网络序 uint32_t ntohl(uint32_t netlong); // 32位整数，网络序 -> 主机序 uint16_t ntohs(uint16_t netshort); // 16位整数，网络序 -> 主机序

一个极易出错的地方：INADDR_ANY（绑定到所有本地接口）和INADDR_LOOPBACK（127.0.0.1）这些常量值，在头文件中定义时是主机字节序的。你不能直接把它们赋值给sockaddr_in.sin_addr.s_addr。必须用htonl转换。

// 错误！可能导致绑定失败或绑定到错误地址。 serv_addr.sin_addr.s_addr = INADDR_ANY; // 正确！ serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

2.3 数据表示与readLine()函数：处理字节流

TCP 是字节流，没有消息边界。readLine()函数是一个经典示例，它展示了如何在流上实现一个简单的应用层协议：读取一行（以换行符\n为结束标志）。

原文给出的readLine()实现有一个关键细节：它一次只读取一个字节。这在网络编程中效率极低，因为每次read系统调用都有上下文切换的开销。在实际项目中，我们通常会实现一个带缓冲的readLine，或者使用标准 I/O 库的fgets（但要注意处理信号中断和错误）。

这里分析一下这个函数的逻辑和注意事项：

1. 参数检查：首先检查缓冲区指针buffer是否有效，以及大小n是否大于 0。
2. 逐字节读取：进入循环，每次从文件描述符fd读取 1 个字节到ch。
3. 处理中断：如果read返回-1且errno == EINTR，表示系统调用被信号中断，这不是错误，应继续读取。
4. 处理 EOF：如果read返回0，表示对端关闭了连接。如果此时还没读到任何字符 (toRead == 0)，则返回 0 表示文件结束；否则，跳出循环，返回已读的字节数（这是一行不完整的最后数据）。
5. 存储字符：如果读取成功，且缓冲区还有空间 (toRead < n-1)，则将字符存入缓冲区，并移动指针。n-1是为了给字符串结尾的\0预留空间。
6. 判断行结束：如果读到换行符\n，则跳出循环。
7. 终止字符串：在缓冲区末尾添加空字符\0，使其成为一个 C 字符串。

注意：这个函数假设换行符是\n。在网络通信中，行结束符可能是\r\n（Windows风格）。一个健壮的实现需要处理这种情况。此外，一次读一个字节的性能问题在真实服务器中是不可接受的，通常我们会用更大的缓冲区（如 4096 字节）进行块读取，然后在内存中搜索换行符。

3. 核心数据结构与地址处理

理解了通信模型和字节序，我们来看看 Linux 如何表示一个网络端点（IP地址+端口号），以及如何在不同表示形式间转换。

3.1 Socket 地址结构：sockaddr_in,sockaddr_in6与sockaddr_storage

网络编程中，我们需要一个结构来承载地址信息。IPv4 使用sockaddr_in：

#include <netinet/in.h> struct in_addr { uint32_t s_addr; /* 网络字节序的 IPv4 地址 */ }; struct sockaddr_in { sa_family_t sin_family; /* 地址族: AF_INET */ in_port_t sin_port; /* 网络字节序的端口号 */ struct in_addr sin_addr; /* IPv4 地址结构 */ unsigned char sin_zero[8]; /* 填充，通常置零 */ };

• sin_family：固定为AF_INET，告诉系统这是 IPv4 地址。
• sin_port：16位端口号，必须使用htons()转换后存入。
• sin_addr.s_addr：32位 IPv4 地址，必须使用htonl(INADDR_ANY)或inet_pton转换后存入。
• sin_zero：为了使sockaddr_in结构和通用的sockaddr结构大小一致而填充的字段，使用前应先用memset或bzero置零。

随着 IPv6 的普及，我们又有了sockaddr_in6：

struct in6_addr { uint8_t s6_addr[16]; /* 128位 IPv6 地址 */ }; struct sockaddr_in6 { sa_family_t sin6_family; /* AF_INET6 */ in_port_t sin6_port; /* 网络字节序的端口号 */ uint32_t sin6_flowinfo; /* IPv6 流信息 */ struct in6_addr sin6_addr; /* IPv6 地址 */ uint32_t sin6_scope_id; /* 作用域 ID */ };

• IPv6 的地址是 128 位，存储在s6_addr这个 16 字节的数组中。
• 通配地址（绑定所有接口）是in6addr_any（一个in6_addr常量），回环地址是in6addr_loopback。
• sin6_flowinfo和sin6_scope_id在一般编程中较少使用。

系统调用（如bind,connect,accept）通常接受通用的struct sockaddr *指针。为了编写能同时处理 IPv4 和 IPv6 的协议无关代码，引入了sockaddr_storage结构。它的空间足够大，可以容纳任何类型的 socket 地址结构，并且进行了内存对齐。

struct sockaddr_storage { sa_family_t ss_family; /* 地址族 */ char __ss_padding[128-sizeof(sa_family_t)]; /* 填充 */ };

用法是：声明一个sockaddr_storage变量，将其地址强制转换为(struct sockaddr *)传递给系统调用，并通过ss_family字段来判断实际类型是AF_INET还是AF_INET6，再进行相应的类型转换和访问。

3.2 地址转换函数：inet_pton与inet_ntop

我们经常需要在“点分十进制字符串”（如“192.168.1.1”）和“网络字节序的二进制值”之间转换 IP 地址。老式的inet_aton和inet_ntoa只支持 IPv4，且inet_ntoa返回静态缓冲区，线程不安全。现代程序应使用inet_pton(presentation to network) 和inet_ntop(network to presentation)。

#include <arpa/inet.h> int inet_pton(int af, const char *src, void *dst); const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

• af：地址族，AF_INET或AF_INET6。
• inet_pton：将字符串src转换为二进制地址存入dst。成功返回 1，格式无效返回 0，出错返回 -1。
• inet_ntop：将二进制地址src转换为字符串存入dst。size指定dst缓冲区大小，必须足够大。对于 IPv4，至少INET_ADDRSTRLEN(16) 字节；对于 IPv6，至少INET6_ADDRSTRLEN(46) 字节。成功返回dst指针，失败返回 NULL。

示例：

struct sockaddr_in addr; char ip_str[INET_ADDRSTRLEN]; // 字符串 -> 二进制 if (inet_pton(AF_INET, “192.168.1.1”, &(addr.sin_addr)) <= 0) { perror(“inet_pton”); exit(EXIT_FAILURE); } // 二进制 -> 字符串 if (inet_ntop(AF_INET, &(addr.sin_addr), ip_str, INET_ADDRSTRLEN) == NULL) { perror(“inet_ntop”); exit(EXIT_FAILURE); } printf(“IP: %s\n”, ip_str);

3.3 独立于协议的主机与服务转换：getaddrinfo与getnameinfo

这是现代网络编程中最重要、也最容易被误用的一组函数。它们封装了 DNS 查询和/etc/services文件查找，能直接给出适合socket,bind,connect使用的地址结构，是编写协议无关（同时支持 IPv4/IPv6）代码的关键。

getaddrinfo()：给定主机名（或IP字符串）和服务名（或端口字符串），返回一个addrinfo结构链表。

#include <sys/types.h> #include <sys/socket.h> #include <netdb.h> int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res); void freeaddrinfo(struct addrinfo *res); const char *gai_strerror(int errcode);

• node：主机名（如“www.example.com”）或数字地址字符串（如“192.168.1.1”）。NULL表示通配地址（用于服务器绑定）。
• service：服务名（如“http”）或十进制端口号字符串（如“8080”）。
• hints：一个addrinfo结构，用于过滤返回的结果。只有ai_flags,ai_family,ai_socktype,ai_protocol字段被使用。
• res：输出参数，指向返回的addrinfo链表头。
• 成功返回 0，失败返回非零错误码，可用gai_strerror()获取错误描述。
• 必须用freeaddrinfo()释放返回的链表。

hints参数详解：

• ai_family:AF_INET(IPv4),AF_INET6(IPv6),AF_UNSPEC(两者皆可)。
• ai_socktype:SOCK_STREAM(TCP),SOCK_DGRAM(UDP),0(两者皆可)。
• ai_protocol: 通常填 0。
• ai_flags: 位掩码，常用组合：
  • AI_PASSIVE：用于服务器绑定。当node为NULL时，返回的地址将是通配地址（INADDR_ANY或in6addr_any）。
  • AI_NUMERICHOST：禁止 DNS 查询，node必须是数字地址字符串。可以避免潜在的、耗时的 DNS 解析。
  • AI_NUMERICSERV：禁止服务名查询，service必须是端口号字符串。
  • AI_ADDRCONFIG：只返回本地系统配置了的协议族地址（例如，如果本机没有 IPv6 地址，则不返回 IPv6 结果）。这在双栈环境中很有用。

getnameinfo()：getaddrinfo()的逆操作，将 socket 地址结构转换为主机名和服务名。

int getnameinfo(const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *service, socklen_t servlen, int flags);

• addr和addrlen指定要转换的 socket 地址。
• host和hostlen用于接收主机名字符串。如果不想获取，可设为NULL和 0。缓冲区大小至少应为NI_MAXHOST(1025)。
• service和servlen用于接收服务名字符串。缓冲区大小至少应为NI_MAXSERV(32)。
• flags：控制行为，例如NI_NUMERICHOST强制返回数字地址而非主机名（避免 DNS 反向查询），NI_NUMERICSERV强制返回端口号。

为什么推荐使用getaddrinfo？

1. 协议无关：一套代码同时支持 IPv4 和 IPv6。
2. 隐藏复杂性：自动处理 DNS 查询、/etc/services查找、地址转换和字节序转换。
3. 返回可直接使用的链表：返回的addrinfo结构中的ai_addr和ai_addrlen可以直接用于bind()、connect()等调用。

4. 实战：构建 UDP 与 TCP 客户端/服务器

理论说得再多，不如一行代码。让我们分别实现一个 UDP 回显服务器/客户端和一个 TCP 序列号服务器/客户端，并在过程中融入所有知识点和避坑技巧。

4.1 UDP 数据报 Socket 示例：回显服务器与客户端

UDP 是无连接的，服务器通常只需一个 socket，通过recvfrom和sendto与多个客户端通信。

UDP 服务器端核心逻辑 (udp_echo_server.c)：

1. 创建 Socket：socket(AF_INET6, SOCK_DGRAM, 0)。这里使用AF_INET6可以同时接受 IPv4 和 IPv6 连接（在支持 IPv4 映射的系统中）。
2. 绑定地址：初始化一个sockaddr_in6结构，将地址族设为AF_INET6，地址设为in6addr_any（通配），端口用htons()转换。然后调用bind()。
3. 循环处理：在一个无限循环中，调用recvfrom()接收数据。该函数会阻塞，直到有数据报到达，并同时告知我们客户端的地址。然后，我们可以用sendto()将数据原样发回给该客户端。

/* 简化的 UDP 服务器循环 */ for (;;) { len = sizeof(claddr); numBytes = recvfrom(sfd, buf, BUF_SIZE, 0, (struct sockaddr *) &claddr, &len); if (numBytes == -1) { perror(“recvfrom”); continue; // 通常继续处理，而非退出 } // 将客户端地址转换为可读字符串 if (inet_ntop(AF_INET6, &claddr.sin6_addr, claddrStr, INET6_ADDRSTRLEN) == NULL) { printf(“Couldn‘t convert client address\n”); } else { printf(“Server received %ld bytes from (%s:%u)\n”, (long)numBytes, claddrStr, ntohs(claddr.sin6_port)); } // 回显数据 if (sendto(sfd, buf, numBytes, 0, (struct sockaddr *) &claddr, len) != numBytes) { perror(“sendto”); } }

UDP 客户端核心逻辑 (udp_echo_client.c)：

1. 创建 Socket：同样使用SOCK_DGRAM。
2. 构造服务器地址：使用inet_pton()将命令行传入的服务器地址字符串转换为二进制格式。
3. 发送与接收：对每个要发送的消息，调用sendto()发送给服务器地址。然后调用recvfrom()等待服务器的回显。注意，这里的recvfrom最后一个参数可以传NULL，因为我们不关心数据来源（我们已经知道是服务器）。

UDP 编程关键点：

• 消息边界：recvfrom一次调用返回一个完整的数据报。缓冲区必须足够大（通常 65507 字节是 IPv4 UDP 的理论最大值，但实际应更小，如 1472 字节以避免 IP 分片）。
• 错误处理：sendto成功只表示数据已交给网络栈，不保证到达。recvfrom可能因为各种原因失败（如 ICMP 端口不可达），应用层需有超时和重传机制。
• 并发：UDP 服务器是迭代的，本身不维护连接状态，可以轻松用多进程/多线程处理，但要注意共享 socket 的线程安全问题。

4.2 TCP 流 Socket 示例：序列号服务器与客户端

TCP 是面向连接的，服务器需要listen()和accept()。

TCP 服务器端核心逻辑 (tcp_seq_server.c)：

1. 创建监听 Socket：使用getaddrinfo()并设置AI_PASSIVE标志，获取适合绑定的地址列表。遍历列表，创建 socket，设置SO_REUSEADDR选项（非常重要，避免 TIME_WAIT 状态导致绑定失败），并尝试bind()和listen()。
2. 接受连接：在循环中调用accept()，它会阻塞直到有客户端连接，并返回一个新的连接 socket 描述符 (cfd)。
3. 处理连接：在新的连接cfd上进行读写操作（如使用前面提到的readLine）。处理完毕后，关闭cfd。监听 socket (lfd) 始终保持打开，等待下一个连接。

/* 简化的 TCP 服务器主循环 */ lfd = create_and_bind_listen_socket(PORT); // 封装了 getaddrinfo, socket, bind, listen if (lfd == -1) { errExit(“Failed to create listen socket”); } for (;;) { addrlen = sizeof(claddr); cfd = accept(lfd, (struct sockaddr *) &claddr, &addrlen); if (cfd == -1) { perror(“accept”); continue; } // 可以使用 getnameinfo 打印客户端信息 // ... 处理客户端请求，例如读取一行，返回序列号 ... close(cfd); // 处理完毕，关闭连接 }

TCP 客户端核心逻辑 (tcp_seq_client.c)：

1. 解析服务器地址：使用getaddrinfo()解析命令行传入的主机名和服务名（端口），并指定ai_socktype为SOCK_STREAM。
2. 连接服务器：遍历getaddrinfo返回的地址列表，尝试socket()和connect()，直到成功。
3. 通信：连接成功后，在 socket 描述符上进行读写。

/* 简化的 TCP 客户端连接部分 */ struct addrinfo hints, *result, *rp; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; // IPv4 or IPv6 hints.ai_socktype = SOCK_STREAM; // TCP socket if (getaddrinfo(hostname, port_str, &hints, &result) != 0) { errExit(“getaddrinfo”); } for (rp = result; rp != NULL; rp = rp->ai_next) { sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); if (sfd == -1) continue; // 尝试下一个地址 if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1) break; // 连接成功 close(sfd); // 连接失败，关闭 socket 继续尝试 } freeaddrinfo(result); if (rp == NULL) { errExit(“Could not connect to any address”); } // 现在 sfd 是一个已连接的 socket，可以读写

TCP 编程关键点：

• SO_REUSEADDR选项：服务器重启时，之前的连接可能处于 TIME_WAIT 状态（约 2MSL 时间），占用着端口。设置此选项允许新的 socket 绑定到同一个端口。通常在bind()之前调用setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval))。
• 并发模型：简单的迭代服务器一次只能处理一个客户端。为了处理并发，可以使用fork()（多进程）、pthread_create()（多线程）或 I/O 多路复用（select/poll/epoll）。
• 字节流与消息边界：必须设计应用层协议。例如，客户端先发送一个代表请求长度的字符串，服务器读取并解析这个长度，然后读取对应字节数的数据。
• 连接关闭：close()调用会触发 TCP 的四次挥手。对端read()会返回 0。要小心“半关闭”状态，可以使用shutdown()来单向关闭连接。

5. 封装与复用：构建自己的 Socket 工具库

在实际项目中，我们不会每次都重复编写getaddrinfo循环和错误处理代码。一个好的实践是封装一些通用的辅助函数。原文最后提供了一组很好的示例：

1. inetConnect()：封装了创建 TCP/UDP socket 并连接到指定主机和服务的逻辑。它处理了getaddrinfo遍历和connect调用，返回一个已连接的 socket 描述符，或 -1 表示失败。
2. inetListen()：封装了创建 TCP 监听 socket 的逻辑。它设置AI_PASSIVE和SO_REUSEADDR，绑定到指定端口，并调用listen。
3. inetBind()：类似于inetListen，但用于 UDP 服务器或需要绑定的客户端，它只bind而不listen。
4. inetAddressStr()：将sockaddr结构转换为可读的“主机名,端口号”字符串，用于日志记录。

将这些函数放入一个独立的头文件和源文件中（如inet_sockets.h/inet_sockets.c），可以极大提升网络编程代码的清晰度和复用性。在编写这些封装函数时，要特别注意错误处理和资源释放（如freeaddrinfo）。

6. 常见陷阱、调试技巧与性能考量

即使理解了所有 API，在实际编码中还是会遇到各种问题。这里分享一些我踩过的坑和总结的经验。

6.1 错误处理与资源泄漏

网络编程中，几乎每个系统调用都可能失败。必须检查返回值。

• socket,bind,listen,accept,connect,sendto,recvfrom：失败返回 -1，设置errno。
• getaddrinfo：失败返回非零错误码，用gai_strerror()获取描述。
• read,write：在阻塞模式下，可能被信号中断（返回 -1，errno=EINTR），需要特殊处理。read返回 0 表示对端关闭连接。
• 资源管理：确保在错误路径上关闭已打开的 socket 描述符。使用getaddrinfo后必须调用freeaddrinfo。

6.2 地址已在使用 (Address already in use)

这是服务器重启时最常见的问题。原因和解决方案：

1. TIME_WAIT 状态：这是 TCP 协议的正常部分，确保最后一个 ACK 丢失后可以重传。解决方案是在bind()之前对监听 socket 设置SO_REUSEADDR选项。
2. 另一个进程正在使用该端口：用netstat -tulnp或lsof -i :端口号找出并终止该进程。

6.3 连接超时、拒绝与重置

• connect超时：对端主机不存在、防火墙拦截或网络路由问题。应设置合理的超时（可以用alarm信号或select/poll的非阻塞模式实现）。
• connect被拒绝：对端主机存在，但目标端口没有进程在监听。检查服务器是否启动、端口是否正确。
• read返回 0：对端正常关闭了连接。
• read/write导致SIGPIPE信号：向一个已收到 RST 的 socket 写数据，默认会触发SIGPIPE信号并终止进程。处理方式：忽略该信号（signal(SIGPIPE, SIG_IGN)），或者检查write的返回值，如果返回-1且errno=EPIPE，则说明连接已断开。

6.4 性能与并发

• 缓冲区大小：TCP/UDP 的发送和接收缓冲区大小会影响性能。可以使用setsockopt设置SO_SNDBUF和SO_RCVBUF，但内核会将其限制在系统范围内。
• TCP_NODELAY选项：默认情况下，TCP 使用 Nagle 算法合并小数据包以减少网络报文数量，但会增加延迟。对于交互式应用（如 Telnet、游戏），可以设置TCP_NODELAY来禁用该算法。
• I/O 模型选择：
  • 多进程/多线程：编程简单，但上下文切换开销大，连接数高时资源消耗大。
  • I/O 多路复用 (select/poll)：单线程处理多个连接，适合连接数中等（如数千），且活跃连接比例不高的场景。select有文件描述符数量限制（通常 1024）。
  • 事件驱动 (epoll/kqueue)：Linux 的epoll是处理数万甚至数十万并发连接的利器。它采用回调机制，只关注活跃的连接，效率极高。这是现代高性能网络服务器（如 Nginx）的基石。

6.5 使用strace和tcpdump调试

当程序行为异常时，光看代码可能不够。

• strace：跟踪进程执行的系统调用。strace -f ./your_server可以查看bind,listen,accept,read,write等调用是否成功，参数是否正确。
• tcpdump或Wireshark：抓取网络数据包。这是终极调试工具。你可以看到三次握手是否完成，数据是否被发送/接收，是否有重传、乱序、丢包。命令如tcpdump -i any -n port 你的端口号。

网络编程是一个实践性极强的领域。理解协议是基础，但真正的能力来自于编码、调试和解决实际问题的过程。从简单的回显服务器开始，逐步尝试实现一个支持多客户端的聊天室，再到一个非阻塞的、基于epoll的高并发服务器，你会对 Linux 网络编程有更深刻的认识。记住，安全、健壮和可维护性永远比追求极致的性能更重要，尤其是在项目初期。