《UNIX环境高级编程》读书笔记17: 网络IPC：套接字

作者: andylin02
学习章节: 第16章 网络IPC：套接字
关键词：套接字；socket；TCP；UDP；网络字节序；三次握手；四次挥手；非阻塞I/O

一、引言

1.1 从进程间通信到网络IPC

在第15章，我们学习了经典UNIX进程间通信（IPC）机制：管道、FIFO、消息队列、信号量和共享内存，这些机制都仅允许在同一台计算机上运行的进程之间通信。

然而，网络时代的应用程序往往需要与运行在其他计算机上的进程交互。本章介绍的网络IPC：套接字（Socket） 正是为了解决这一问题而设计的。

1.2 套接字的设计目标

套接字接口的目标非常优雅：同样的接口既可以用于计算机间通信，又可以用于计算机内通信。通过这一接口，目标进程运行的位置对调用者来说是透明的——它们可以在同一台计算机上，也可以在不同的计算机上。

💡 设计哲学：套接字接口的设计体现了UNIX“一切皆文件”的理念——套接字描述符在UNIX系统中被当作一种文件描述符来处理，可以使用read、write、close等熟悉的文件I/O函数进行网络通信。

二、套接字描述符

2.1 socket函数：创建套接字

套接字是通信端点的抽象。要创建一个套接字，需要调用socket函数：

#include <sys/socket.h>

int socket(int domain, int type, int protocol);
// 返回值：若成功，返回套接字描述符；若出错，返回-1

参数详解：

📖 拓展知识：AF_（Address Family）地址族和PF_（Protocol Family）协议族在历史上曾有不同的语义，但现在大多数系统上它们是等价的。PF_LOCAL是PF_UNIX的别名，后者已废弃。

2.2 close与shutdown：关闭套接字

当不再需要套接字时，可以使用close函数关闭对套接字的访问。然而，套接字通信是双向的，有时候我们可能只想关闭一个方向。这时就需要用到shutdown函数：

#include <sys/socket.h>

int shutdown(int sockfd, int how);
// 返回值：若成功，返回0；若出错，返回-1

how参数的取值：

为什么需要shutdown而不只用close？

close只有在最后一个引用该套接字的文件描述符被关闭时才会真正释放网络端点。而shutdown允许使套接字处于不活动状态，与引用它的文件描述符数目无关，并且可以很方便地关闭双向传输中的某一个方向。

三、寻址：找到通信目标

3.1 进程标识的组成

要标识一个目标通信进程，需要两个部分的信息：

📖 端口号：TCP/IP协议中，端口号是传输层对网络服务的封装。IP地址:端口号的组合（即socket）唯一标识了网络中的一个通信端点。

3.2 字节序：大端 vs 小端

字节序是一个处理器架构的特性，用于指示像整数这样的大数据类型内部的字节如何排序：

网络字节序：TCP/IP协议栈使用大端字节序。因此，不同字节序架构的计算机之间通信时，需要进行字节序转换。

3.3 字节序转换函数

#include <arpa/inet.h>

uint32_t htonl(uint32_t hostint32); // 32位主机字节序 → 网络字节序
uint16_t htons(uint16_t hostint16); // 16位主机字节序 → 网络字节序
uint32_t ntohl(uint32_t netint32); // 32位网络字节序 → 主机字节序
uint16_t ntohs(uint16_t netint16); // 16位网络字节序 → 主机字节序

💡 命名规律：h代表host，n代表network，l代表long（32位），s代表short（16位）。

3.4 套接字地址结构

3.4.1 通用套接字地址结构 sockaddr

在Linux中，套接字地址结构定义如下：

struct sockaddr {
sa_family_t sa_family; /* 地址族 */
char sa_data[14]; /* 可变长度的地址数据 */
};

3.4.2 IPv4套接字地址结构 sockaddr_in

在实际编程中，我们更常用的是针对IPv4的sockaddr_in结构：

#include <netinet/in.h>

struct in_addr {
in_addr_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]; /* 填充字节，使大小与sockaddr一致 */
};

3.5 地址转换函数：inet_pton和inet_ntop

现代网络编程推荐使用inet_pton（Presentation to Numeric）和inet_ntop（Numeric to Presentation）进行地址转换：

#include <arpa/inet.h>

/* 将点分十进制字符串 → 二进制网络字节序地址 */
int inet_pton(int af, const char *src, void *dst);
// af: AF_INET 或 AF_INET6
// 返回值：成功返回1，格式无效返回0，出错返回-1

/* 将二进制网络字节序地址 → 点分十进制字符串 */
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
// 返回值：成功返回dst，出错返回NULL

3.6 bind函数：将地址绑定到套接字

服务器需要将一个众所周知的地址绑定到套接字上，以便客户端能够找到它。这通过bind函数完成：

#include <sys/socket.h>

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
// 返回值：成功返回0，出错返回-1

四、建立连接

4.1 connect：客户端发起连接

客户端使用connect函数建立与服务器的连接：

#include <sys/socket.h>

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
// 返回值：成功返回0，出错返回-1

4.2 listen：服务器宣告可接受连接

服务器调用listen来宣告可以接受连接请求：

#include <sys/socket.h>

int listen(int sockfd, int backlog);
// 返回值：成功返回0，出错返回-1

backlog参数用于指定未决连接队列的最大长度，即已经完成三次握手但尚未被accept接受的连接数上限。

4.3 accept：接收连接请求

使用accept函数获得连接请求并建立连接：

#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *restrict addr, socklen_t *restrict len);
// 返回值：若成功，返回代表已连接套接字的文件描述符；若出错，返回-1

📖 重要理解：accept所返回的文件描述符是一个新的套接字描述符，该描述符连接到调用connect的客户端。原始的监听套接字（sockfd）仍然保持打开状态，继续接收后续的连接请求。

五、数据传输

套接字提供了多个函数用于数据传输，既可以像文件I/O一样使用read/write，也可以使用专门设计的函数以获得更多控制能力。

5.1 发送数据

#include <sys/socket.h>

ssize_t send(int sockfd, const void *buf, size_t nbytes, int flags);
// 返回值：若成功，返回发送的字节数；若出错，返回-1

send函数与write类似，但可以指定flags标志来改变处理传输数据的方式。

ssize_t sendto(int sockfd, const void *buf, size_t nbytes, int flags,
const struct sockaddr *destaddr, socklen_t destlen);

sendto与send类似，但区别在于允许在无连接的套接字（如UDP）上指定目标地址。

ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);

sendmsg支持使用msghdr结构指定多重缓冲区传输数据，与writev类似。

5.2 接收数据

#include <sys/socket.h>

ssize_t recv(int sockfd, void *buf, size_t nbytes, int flags);
// 返回值：若成功，返回数据的字节数；若无可用数据，返回0；若出错，返回-1

ssize_t recvfrom(int sockfd, void *restrict buf, size_t len, int flags,
struct sockaddr *restrict addr, socklen_t *restrict addrlen);
// 返回值：成功返回接收字节数，出错返回-1

recvfrom可以得到数据发送者的源地址，常用于UDP通信。

ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
// 返回值：成功返回接收字节数，出错返回-1

recvmsg可以将接收到的数据送入多个缓冲区，类似于readv。

六、TCP编程完整示例

6.1 TCP服务器端完整代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 8888
#define BUFFER_SIZE 1024
#define BACKLOG 5

int main(void)
{
int listen_fd, conn_fd;
struct sockaddr_in server_addr, client_addr;
socklen_t client_len;
char buffer[BUFFER_SIZE];
ssize_t n;

/* 1. 创建套接字 */
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (listen_fd < 0) {
perror("socket error");
exit(1);
}

/* 设置SO_REUSEADDR选项，避免端口被占用时bind失败 */
int opt = 1;
if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
perror("setsockopt error");
exit(1);
}

/* 2. 绑定地址 */
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* 监听所有网络接口 */
server_addr.sin_port = htons(PORT);

if (bind(listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("bind error");
exit(1);
}

/* 3. 监听 */
if (listen(listen_fd, BACKLOG) < 0) {
perror("listen error");
exit(1);
}

printf("TCP服务器启动，监听端口 %d…\\n", PORT);

/* 4. 接受客户端连接 */
client_len = sizeof(client_addr);
conn_fd = accept(listen_fd, (struct sockaddr *)&client_addr, &client_len);
if (conn_fd < 0) {
perror("accept error");
exit(1);
}

printf("客户端已连接: %s:%d\\n",
inet_ntoa(client_addr.sin_addr),
ntohs(client_addr.sin_port));

/* 5. 收发数据 */
while ((n = recv(conn_fd, buffer, BUFFER_SIZE – 1, 0)) > 0) {
buffer[n] = '\\0';
printf("收到消息: %s", buffer);

/* 回显消息 */
if (send(conn_fd, buffer, n, 0) != n) {
perror("send error");
break;
}
}

if (n < 0) {
perror("recv error");
} else if (n == 0) {
printf("客户端已断开连接\\n");
}

/* 6. 关闭连接 */
close(conn_fd);
close(listen_fd);

return 0;
}

6.2 TCP客户端完整代码

#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 8888
#define BUFFER_SIZE 1024

int main(int argc, char *argv[])
{
int sock_fd;
struct sockaddr_in server_addr;
char buffer[BUFFER_SIZE];
ssize_t n;

if (argc != 2) {
fprintf(stderr, "用法: %s <服务器IP>\\n", argv[0]);
exit(1);
}

/* 1. 创建套接字 */
sock_fd = socket(AF_INET, SOCK_STREAM, 0);
if (sock_fd < 0) {
perror("socket error");
exit(1);
}

/* 2. 设置服务器地址 */
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVER_PORT);
if (inet_pton(AF_INET, argv[1], &server_addr.sin_addr) <= 0) {
perror("inet_pton error");
exit(1);
}

/* 3. 连接服务器 */
if (connect(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("connect error");
exit(1);
}

printf("已连接到服务器 %s:%d\\n", argv[1], SERVER_PORT);

/* 4. 发送并接收数据 */
while (1) {
printf("请输入消息 (输入quit退出): ");
if (fgets(buffer, BUFFER_SIZE, stdin) == NULL) {
break;
}

/* 发送数据 */
if (send(sock_fd, buffer, strlen(buffer), 0) != (ssize_t)strlen(buffer)) {
perror("send error");
break;
}

/* 如果输入quit，退出循环 */
if (strncmp(buffer, "quit", 4) == 0) {
break;
}

/* 接收服务器回显 */
n = recv(sock_fd, buffer, BUFFER_SIZE – 1, 0);
if (n > 0) {
buffer[n] = '\\0';
printf("服务器回显: %s", buffer);
} else if (n == 0) {
printf("服务器已关闭连接\\n");
break;
} else {
perror("recv error");
break;
}
}

/* 5. 关闭套接字 */
close(sock_fd);

return 0;
}

6.3 TCP三次握手与四次挥手流程图

服务器客户端服务器客户端#mermaid-svg-NtgBisOEX9HjIJVd{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-NtgBisOEX9HjIJVd .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-NtgBisOEX9HjIJVd .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-NtgBisOEX9HjIJVd .error-icon{fill:#552222;}#mermaid-svg-NtgBisOEX9HjIJVd .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-NtgBisOEX9HjIJVd .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-NtgBisOEX9HjIJVd .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-NtgBisOEX9HjIJVd .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-NtgBisOEX9HjIJVd .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-NtgBisOEX9HjIJVd .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-NtgBisOEX9HjIJVd .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-NtgBisOEX9HjIJVd .marker{fill:#333333;stroke:#333333;}#mermaid-svg-NtgBisOEX9HjIJVd .marker.cross{stroke:#333333;}#mermaid-svg-NtgBisOEX9HjIJVd svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-NtgBisOEX9HjIJVd p{margin:0;}#mermaid-svg-NtgBisOEX9HjIJVd .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-NtgBisOEX9HjIJVd text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-NtgBisOEX9HjIJVd .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-NtgBisOEX9HjIJVd .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-NtgBisOEX9HjIJVd .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-NtgBisOEX9HjIJVd .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-NtgBisOEX9HjIJVd #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-NtgBisOEX9HjIJVd .sequenceNumber{fill:white;}#mermaid-svg-NtgBisOEX9HjIJVd #sequencenumber{fill:#333;}#mermaid-svg-NtgBisOEX9HjIJVd #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-NtgBisOEX9HjIJVd .messageText{fill:#333;stroke:none;}#mermaid-svg-NtgBisOEX9HjIJVd .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-NtgBisOEX9HjIJVd .labelText,#mermaid-svg-NtgBisOEX9HjIJVd .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-NtgBisOEX9HjIJVd .loopText,#mermaid-svg-NtgBisOEX9HjIJVd .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-NtgBisOEX9HjIJVd .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-NtgBisOEX9HjIJVd .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-NtgBisOEX9HjIJVd .noteText,#mermaid-svg-NtgBisOEX9HjIJVd .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-NtgBisOEX9HjIJVd .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-NtgBisOEX9HjIJVd .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-NtgBisOEX9HjIJVd .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-NtgBisOEX9HjIJVd .actorPopupMenu{position:absolute;}#mermaid-svg-NtgBisOEX9HjIJVd .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-NtgBisOEX9HjIJVd .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-NtgBisOEX9HjIJVd .actor-man circle,#mermaid-svg-NtgBisOEX9HjIJVd line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-NtgBisOEX9HjIJVd :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}三次握手建立连接连接已建立，开始数据传输数据传输阶段四次挥手断开连接服务器关闭读通道客户端关闭写通道1. SYN (seq=x)2. SYN + ACK (seq=y, ack=x+1)3. ACK (ack=y+1)数据 (data)ACK数据 (data)ACK1. FIN (seq=u)2. ACK (ack=u+1)3. FIN (seq=v)4. ACK (ack=v+1)

七、UDP编程完整示例

7.1 UDP服务器端完整代码

#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 PORT 8888
#define BUFFER_SIZE 1024

int main(void)
{
int sock_fd;
struct sockaddr_in server_addr, client_addr;
socklen_t client_len;
char buffer[BUFFER_SIZE];
ssize_t n;

/* 1. 创建UDP套接字 */
sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
if (sock_fd < 0) {
perror("socket error");
exit(1);
}

/* 2. 绑定地址 */
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(PORT);

if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("bind error");
exit(1);
}

printf("UDP服务器启动，监听端口 %d…\\n", PORT);

/* 3. 接收并处理数据 */
client_len = sizeof(client_addr);
while (1) {
n = recvfrom(sock_fd, buffer, BUFFER_SIZE – 1, 0,
(struct sockaddr *)&client_addr, &client_len);
if (n < 0) {
perror("recvfrom error");
continue;
}

buffer[n] = '\\0';
printf("收到来自 %s:%d 的消息: %s\\n",
inet_ntoa(client_addr.sin_addr),
ntohs(client_addr.sin_port),
buffer);

/* 回显消息 */
if (sendto(sock_fd, buffer, n, 0,
(struct sockaddr *)&client_addr, client_len) != n) {
perror("sendto error");
}
}

close(sock_fd);
return 0;
}

7.2 UDP客户端完整代码

#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 8888
#define BUFFER_SIZE 1024

int main(int argc, char *argv[])
{
int sock_fd;
struct sockaddr_in server_addr;
char buffer[BUFFER_SIZE];
socklen_t addr_len;
ssize_t n;

if (argc != 2) {
fprintf(stderr, "用法: %s <服务器IP>\\n", argv[0]);
exit(1);
}

/* 1. 创建UDP套接字 */
sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
if (sock_fd < 0) {
perror("socket error");
exit(1);
}

/* 2. 设置服务器地址 */
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVER_PORT);
if (inet_pton(AF_INET, argv[1], &server_addr.sin_addr) <= 0) {
perror("inet_pton error");
exit(1);
}

printf("UDP客户端启动，目标服务器 %s:%d\\n", argv[1], SERVER_PORT);

addr_len = sizeof(server_addr);

while (1) {
printf("请输入消息 (输入quit退出): ");
if (fgets(buffer, BUFFER_SIZE, stdin) == NULL) {
break;
}

/* 发送数据 */
if (sendto(sock_fd, buffer, strlen(buffer), 0,
(struct sockaddr *)&server_addr, addr_len) != (ssize_t)strlen(buffer)) {
perror("sendto error");
break;
}

/* 如果输入quit，退出循环 */
if (strncmp(buffer, "quit", 4) == 0) {
break;
}

/* 接收服务器回显 */
n = recvfrom(sock_fd, buffer, BUFFER_SIZE – 1, 0, NULL, NULL);
if (n > 0) {
buffer[n] = '\\0';
printf("服务器回显: %s", buffer);
} else {
perror("recvfrom error");
break;
}
}

close(sock_fd);
return 0;
}

八、TCP与UDP的对比

8.1 核心差异

8.2 编程流程对比

8.3 应用场景选择

TCP适用场景：

• 需要数据可靠传输的场景（如文件传输、电子邮件、网页浏览）
• 数据顺序有严格要求的场景
• 需要长连接交互的应用

UDP适用场景：

• 对实时性要求高、可以容忍少量丢包的场景（如视频通话、在线游戏）
• 广播/多播通信
• DNS查询等短事务通信

九、套接字选项

套接字机制提供两个套接字选项接口来控制套接字行为：

#include <sys/socket.h>

int setsockopt(int sockfd, int level, int option, const void *val, socklen_t len);
int getsockopt(int sockfd, int level, int option, void *restrict val, socklen_t *restrict lenp);
// 返回值：成功返回0，出错返回-1

选项的分类：

十、非阻塞I/O与异步I/O

默认情况下，recv函数在没有数据可用时会阻塞等待。同样地，当套接字输出队列没有足够空间来发送消息时，send函数会阻塞。在套接字非阻塞模式下，行为会改变——这些函数不会阻塞，而是失败并设置errno为EAGAIN或EWOULDBLOCK。

设置非阻塞模式的方法：

int flags = fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);

💡 学习建议：第14章“高级I/O”中详细介绍了select、poll和epoll等I/O多路转接技术，这些技术与套接字非阻塞I/O结合，是实现高性能网络服务器的基础。

十一、标准I/O与套接字的配合使用

11.1 为什么需要特殊处理？

套接字作为全双工通信端点，使用标准I/O库时需要特别注意缓冲问题：

• 标准I/O流可以是全双工的（以r+类型打开）
• 但在这样的流上，必须在输出函数后插入fflush调用才能接着调用输入函数
• 标准I/O的缓冲机制可能导致数据延迟发送（完全缓冲时，数据会等缓冲区满后才发送）

11.2 解决方案：使用fdopen分离读写流

推荐的解决方案是为一个给定套接字打开两个标准I/O流：一个用于读，一个用于写：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>

int sockfd = socket(AF_INET, SOCK_STREAM, 0);
/* 绑定、连接等操作… */

/* 使用dup复制文件描述符，避免双关闭问题 */
FILE *readfp = fdopen(sockfd, "r");
FILE *writefp = fdopen(dup(sockfd), "w");

/* 分别使用fgets/fputs进行读写操作 */

/* 关闭时分别关闭两个流 */
fclose(readfp);
fclose(writefp);

为什么使用dup复制文件描述符？

如果在同一个文件描述符上调用两次fdopen并分别关闭，会导致“双关闭”问题。在多线程程序中，这可能引起严重的数据损坏。使用dup复制描述符可以避免这一问题。

十二、架构图与流程图

12.1 TCP通信全流程图

#mermaid-svg-5BaCfmyVYjQsNWqZ{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-5BaCfmyVYjQsNWqZ .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-5BaCfmyVYjQsNWqZ .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-5BaCfmyVYjQsNWqZ .error-icon{fill:#552222;}#mermaid-svg-5BaCfmyVYjQsNWqZ .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-5BaCfmyVYjQsNWqZ .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-5BaCfmyVYjQsNWqZ .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-5BaCfmyVYjQsNWqZ .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-5BaCfmyVYjQsNWqZ .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-5BaCfmyVYjQsNWqZ .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-5BaCfmyVYjQsNWqZ .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-5BaCfmyVYjQsNWqZ .marker{fill:#333333;stroke:#333333;}#mermaid-svg-5BaCfmyVYjQsNWqZ .marker.cross{stroke:#333333;}#mermaid-svg-5BaCfmyVYjQsNWqZ svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-5BaCfmyVYjQsNWqZ p{margin:0;}#mermaid-svg-5BaCfmyVYjQsNWqZ .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-5BaCfmyVYjQsNWqZ .cluster-label text{fill:#333;}#mermaid-svg-5BaCfmyVYjQsNWqZ .cluster-label span{color:#333;}#mermaid-svg-5BaCfmyVYjQsNWqZ .cluster-label span p{background-color:transparent;}#mermaid-svg-5BaCfmyVYjQsNWqZ .label text,#mermaid-svg-5BaCfmyVYjQsNWqZ span{fill:#333;color:#333;}#mermaid-svg-5BaCfmyVYjQsNWqZ .node rect,#mermaid-svg-5BaCfmyVYjQsNWqZ .node circle,#mermaid-svg-5BaCfmyVYjQsNWqZ .node ellipse,#mermaid-svg-5BaCfmyVYjQsNWqZ .node polygon,#mermaid-svg-5BaCfmyVYjQsNWqZ .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-5BaCfmyVYjQsNWqZ .rough-node .label text,#mermaid-svg-5BaCfmyVYjQsNWqZ .node .label text,#mermaid-svg-5BaCfmyVYjQsNWqZ .image-shape .label,#mermaid-svg-5BaCfmyVYjQsNWqZ .icon-shape .label{text-anchor:middle;}#mermaid-svg-5BaCfmyVYjQsNWqZ .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-5BaCfmyVYjQsNWqZ .rough-node .label,#mermaid-svg-5BaCfmyVYjQsNWqZ .node .label,#mermaid-svg-5BaCfmyVYjQsNWqZ .image-shape .label,#mermaid-svg-5BaCfmyVYjQsNWqZ .icon-shape .label{text-align:center;}#mermaid-svg-5BaCfmyVYjQsNWqZ .node.clickable{cursor:pointer;}#mermaid-svg-5BaCfmyVYjQsNWqZ .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-5BaCfmyVYjQsNWqZ .arrowheadPath{fill:#333333;}#mermaid-svg-5BaCfmyVYjQsNWqZ .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-5BaCfmyVYjQsNWqZ .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-5BaCfmyVYjQsNWqZ .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-5BaCfmyVYjQsNWqZ .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-5BaCfmyVYjQsNWqZ .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-5BaCfmyVYjQsNWqZ .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-5BaCfmyVYjQsNWqZ .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-5BaCfmyVYjQsNWqZ .cluster text{fill:#333;}#mermaid-svg-5BaCfmyVYjQsNWqZ .cluster span{color:#333;}#mermaid-svg-5BaCfmyVYjQsNWqZ div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-5BaCfmyVYjQsNWqZ .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-5BaCfmyVYjQsNWqZ rect.text{fill:none;stroke-width:0;}#mermaid-svg-5BaCfmyVYjQsNWqZ .icon-shape,#mermaid-svg-5BaCfmyVYjQsNWqZ .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-5BaCfmyVYjQsNWqZ .icon-shape p,#mermaid-svg-5BaCfmyVYjQsNWqZ .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-5BaCfmyVYjQsNWqZ .icon-shape .label rect,#mermaid-svg-5BaCfmyVYjQsNWqZ .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-5BaCfmyVYjQsNWqZ .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-5BaCfmyVYjQsNWqZ .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-5BaCfmyVYjQsNWqZ :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

客户端

服务器端

三次握手

数据传输

四次挥手

socket() 创建监听套接字

bind() 绑定地址端口

listen() 设置监听队列

accept() 阻塞等待连接

recv()/send() 读写数据

close() 关闭连接套接字

socket() 创建套接字

connect() 连接服务器

send()/recv() 读写数据

close() 关闭套接字

12.2 UDP通信全流程图

#mermaid-svg-j3dXpCplkE9e4ZON{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-j3dXpCplkE9e4ZON .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-j3dXpCplkE9e4ZON .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-j3dXpCplkE9e4ZON .error-icon{fill:#552222;}#mermaid-svg-j3dXpCplkE9e4ZON .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-j3dXpCplkE9e4ZON .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-j3dXpCplkE9e4ZON .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-j3dXpCplkE9e4ZON .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-j3dXpCplkE9e4ZON .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-j3dXpCplkE9e4ZON .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-j3dXpCplkE9e4ZON .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-j3dXpCplkE9e4ZON .marker{fill:#333333;stroke:#333333;}#mermaid-svg-j3dXpCplkE9e4ZON .marker.cross{stroke:#333333;}#mermaid-svg-j3dXpCplkE9e4ZON svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-j3dXpCplkE9e4ZON p{margin:0;}#mermaid-svg-j3dXpCplkE9e4ZON .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-j3dXpCplkE9e4ZON .cluster-label text{fill:#333;}#mermaid-svg-j3dXpCplkE9e4ZON .cluster-label span{color:#333;}#mermaid-svg-j3dXpCplkE9e4ZON .cluster-label span p{background-color:transparent;}#mermaid-svg-j3dXpCplkE9e4ZON .label text,#mermaid-svg-j3dXpCplkE9e4ZON span{fill:#333;color:#333;}#mermaid-svg-j3dXpCplkE9e4ZON .node rect,#mermaid-svg-j3dXpCplkE9e4ZON .node circle,#mermaid-svg-j3dXpCplkE9e4ZON .node ellipse,#mermaid-svg-j3dXpCplkE9e4ZON .node polygon,#mermaid-svg-j3dXpCplkE9e4ZON .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-j3dXpCplkE9e4ZON .rough-node .label text,#mermaid-svg-j3dXpCplkE9e4ZON .node .label text,#mermaid-svg-j3dXpCplkE9e4ZON .image-shape .label,#mermaid-svg-j3dXpCplkE9e4ZON .icon-shape .label{text-anchor:middle;}#mermaid-svg-j3dXpCplkE9e4ZON .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-j3dXpCplkE9e4ZON .rough-node .label,#mermaid-svg-j3dXpCplkE9e4ZON .node .label,#mermaid-svg-j3dXpCplkE9e4ZON .image-shape .label,#mermaid-svg-j3dXpCplkE9e4ZON .icon-shape .label{text-align:center;}#mermaid-svg-j3dXpCplkE9e4ZON .node.clickable{cursor:pointer;}#mermaid-svg-j3dXpCplkE9e4ZON .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-j3dXpCplkE9e4ZON .arrowheadPath{fill:#333333;}#mermaid-svg-j3dXpCplkE9e4ZON .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-j3dXpCplkE9e4ZON .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-j3dXpCplkE9e4ZON .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-j3dXpCplkE9e4ZON .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-j3dXpCplkE9e4ZON .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-j3dXpCplkE9e4ZON .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-j3dXpCplkE9e4ZON .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-j3dXpCplkE9e4ZON .cluster text{fill:#333;}#mermaid-svg-j3dXpCplkE9e4ZON .cluster span{color:#333;}#mermaid-svg-j3dXpCplkE9e4ZON div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-j3dXpCplkE9e4ZON .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-j3dXpCplkE9e4ZON rect.text{fill:none;stroke-width:0;}#mermaid-svg-j3dXpCplkE9e4ZON .icon-shape,#mermaid-svg-j3dXpCplkE9e4ZON .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-j3dXpCplkE9e4ZON .icon-shape p,#mermaid-svg-j3dXpCplkE9e4ZON .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-j3dXpCplkE9e4ZON .icon-shape .label rect,#mermaid-svg-j3dXpCplkE9e4ZON .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-j3dXpCplkE9e4ZON .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-j3dXpCplkE9e4ZON .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-j3dXpCplkE9e4ZON :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

客户端

服务器端

数据报

数据报

socket() 创建UDP套接字

bind() 绑定地址端口

recvfrom() 阻塞等待数据

sendto() 发送响应

socket() 创建UDP套接字

sendto() 发送数据到服务器

recvfrom() 接收服务器响应

close() 关闭套接字

12.3 套接字类型选择决策树

#mermaid-svg-o3W2TmCvDFS5dVQY{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-o3W2TmCvDFS5dVQY .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-o3W2TmCvDFS5dVQY .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-o3W2TmCvDFS5dVQY .error-icon{fill:#552222;}#mermaid-svg-o3W2TmCvDFS5dVQY .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-o3W2TmCvDFS5dVQY .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-o3W2TmCvDFS5dVQY .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-o3W2TmCvDFS5dVQY .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-o3W2TmCvDFS5dVQY .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-o3W2TmCvDFS5dVQY .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-o3W2TmCvDFS5dVQY .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-o3W2TmCvDFS5dVQY .marker{fill:#333333;stroke:#333333;}#mermaid-svg-o3W2TmCvDFS5dVQY .marker.cross{stroke:#333333;}#mermaid-svg-o3W2TmCvDFS5dVQY svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-o3W2TmCvDFS5dVQY p{margin:0;}#mermaid-svg-o3W2TmCvDFS5dVQY .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-o3W2TmCvDFS5dVQY .cluster-label text{fill:#333;}#mermaid-svg-o3W2TmCvDFS5dVQY .cluster-label span{color:#333;}#mermaid-svg-o3W2TmCvDFS5dVQY .cluster-label span p{background-color:transparent;}#mermaid-svg-o3W2TmCvDFS5dVQY .label text,#mermaid-svg-o3W2TmCvDFS5dVQY span{fill:#333;color:#333;}#mermaid-svg-o3W2TmCvDFS5dVQY .node rect,#mermaid-svg-o3W2TmCvDFS5dVQY .node circle,#mermaid-svg-o3W2TmCvDFS5dVQY .node ellipse,#mermaid-svg-o3W2TmCvDFS5dVQY .node polygon,#mermaid-svg-o3W2TmCvDFS5dVQY .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-o3W2TmCvDFS5dVQY .rough-node .label text,#mermaid-svg-o3W2TmCvDFS5dVQY .node .label text,#mermaid-svg-o3W2TmCvDFS5dVQY .image-shape .label,#mermaid-svg-o3W2TmCvDFS5dVQY .icon-shape .label{text-anchor:middle;}#mermaid-svg-o3W2TmCvDFS5dVQY .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-o3W2TmCvDFS5dVQY .rough-node .label,#mermaid-svg-o3W2TmCvDFS5dVQY .node .label,#mermaid-svg-o3W2TmCvDFS5dVQY .image-shape .label,#mermaid-svg-o3W2TmCvDFS5dVQY .icon-shape .label{text-align:center;}#mermaid-svg-o3W2TmCvDFS5dVQY .node.clickable{cursor:pointer;}#mermaid-svg-o3W2TmCvDFS5dVQY .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-o3W2TmCvDFS5dVQY .arrowheadPath{fill:#333333;}#mermaid-svg-o3W2TmCvDFS5dVQY .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-o3W2TmCvDFS5dVQY .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-o3W2TmCvDFS5dVQY .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-o3W2TmCvDFS5dVQY .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-o3W2TmCvDFS5dVQY .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-o3W2TmCvDFS5dVQY .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-o3W2TmCvDFS5dVQY .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-o3W2TmCvDFS5dVQY .cluster text{fill:#333;}#mermaid-svg-o3W2TmCvDFS5dVQY .cluster span{color:#333;}#mermaid-svg-o3W2TmCvDFS5dVQY div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-o3W2TmCvDFS5dVQY .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-o3W2TmCvDFS5dVQY rect.text{fill:none;stroke-width:0;}#mermaid-svg-o3W2TmCvDFS5dVQY .icon-shape,#mermaid-svg-o3W2TmCvDFS5dVQY .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-o3W2TmCvDFS5dVQY .icon-shape p,#mermaid-svg-o3W2TmCvDFS5dVQY .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-o3W2TmCvDFS5dVQY .icon-shape .label rect,#mermaid-svg-o3W2TmCvDFS5dVQY .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-o3W2TmCvDFS5dVQY .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-o3W2TmCvDFS5dVQY .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-o3W2TmCvDFS5dVQY :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

是

否

是

否

是

否

需要进程间通信

进程在同一台计算机上？

使用第15章IPC管道/FIFO/消息队列/共享内存

需要可靠传输？

选择TCPSOCK_STREAM

需要实时性可容忍丢包？

选择UDPSOCK_DGRAM

考虑SCTPSOCK_SEQPACKET

三次握手、流量控制、拥塞控制

无连接、低延迟、广播/多播

十三、常见问题与注意事项

💡 关键要点：

十四、总结

本章系统介绍了UNIX网络IPC——套接字编程的核心知识，主要包括：

套接字接口是现代网络编程的基石。无论是Web服务器、数据库服务还是即时通讯应用，其底层都离不开套接字。理解本章的内容，是迈向高性能网络编程的重要一步。

十五、下篇预告

第17章《高级进程间通信》 将介绍：

• UNIX域套接字：本机进程间通信的高效方式
• 命名空间与高级Socket特性
• 多种IPC机制的综合运用与选择策略
• 进程间通信的性能比较与优化

本文为个人学习笔记，仅用于知识分享。如有错误，欢迎指正。
👍🏻 点赞 + 收藏 + 分享，让更多开发者看到这篇深度解析！❤️ 如果觉得有用，请给个赞支持一下作者！