Linux/UNIX系统编程手册笔记：SOCKET

Socket 详解：网络通信的基石

在网络编程领域，Socket 是实现进程间网络通信的核心工具。它为不同主机或同一主机的进程提供了数据传输通道，支持 TCP、UDP 等多种协议。本文将从基础到实践，拆解 Socket 的创建、连接、数据传输等关键环节，带你掌握网络通信的底层逻辑。

一、概述

（一）Socket 的核心价值

Socket（套接字）是操作系统提供的网络通信接口，实现：

• 跨主机通信：让不同主机的进程通过网络交换数据（如 Web 浏览器与服务器 ）。
• 协议支持：兼容 TCP（可靠流传输 ）、UDP（不可靠数据报 ）等协议。
• 进程解耦：客户端与服务器无需同时在线，通过网络协议实现异步通信。

典型场景：Web 服务（HTTP 基于 TCP Socket ）、即时通讯（UDP/TCP 结合 ）、文件传输（FTP 基于 Socket ）。

二、创建一个 socket：socket()

（一）socket 函数原型

#include <sys/socket.h>
int socket(int domain, int type, int protocol);

• domain：地址族（如 AF_INET 表示 IPv4 、AF_INET6 表示 IPv6 ）。
• type：套接字类型（SOCK_STREAM 流套接字，SOCK_DGRAM 数据报套接字 ）。
• protocol：协议（通常传 0，由 domain 和 type 推导 ）。

（二）示例：创建 TCP Socket

// 创建 IPv4 TCP Socket
int sock = socket(AF_INET, SOCK_STREAM, 0); 
if (sock == -1) { perror("socket"); return 1; }

• AF_INET + SOCK_STREAM 对应 TCP 协议，protocol 自动设为 IPPROTO_TCP。

三、将 socket 绑定到地址：bind()

（一）bind 函数原型

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

• sockfd：socket 创建的套接字描述符。
• addr：套接字地址结构体（如 struct sockaddr_in 用于 IPv4 ）。
• addrlen：地址结构体长度。

（二）示例：绑定到 IPv4 地址

struct sockaddr_in addr;
addr.sin_family = AF_INET;
// 绑定到所有网络接口（INADDR_ANY）
addr.sin_addr.s_addr = INADDR_ANY; 
// 绑定到 8080 端口
addr.sin_port = htons(8080); if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) == -1) {perror("bind");return 1;
}

• htons：将主机字节序转换为网络字节序（端口号需网络字节序 ）。
• INADDR_ANY：表示绑定到所有可用网络接口，适合服务器监听。

四、通用 socket 地址结构：struct sockaddr

sockaddr 是通用地址结构体，不同协议族有具体实现（如 sockaddr_in 用于 IPv4 、sockaddr_in6 用于 IPv6 ）：

struct sockaddr {sa_family_t sa_family; // 地址族（如 AF_INET）char sa_data[14];      // 地址数据（不同协议族格式不同）
};// IPv4 具体地址结构
struct sockaddr_in {sa_family_t sin_family; // AF_INETin_port_t sin_port;     // 端口（网络字节序）struct in_addr sin_addr; // IPv4 地址
};

使用时需强制类型转换（如 (struct sockaddr*)&addr_in ），确保兼容性。

五、流 socket（TCP）

（一）监听接入连接：listen()

int listen(int sockfd, int backlog);

• backlog：等待连接队列的最大长度（超过则拒绝新连接 ）。

示例：启动 TCP 监听

// 监听队列长度设为 10
if (listen(sock, 10) == -1) { perror("listen");return 1;
}

（二）接受连接：accept()

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

• 返回新的套接字描述符（用于与客户端通信 ），原套接字继续监听。

示例：接受客户端连接

struct sockaddr_in client_addr;
socklen_t addrlen = sizeof(client_addr);
// 阻塞等待客户端连接
int client_sock = accept(sock, (struct sockaddr*)&client_addr, &addrlen); 
if (client_sock == -1) { perror("accept"); return 1; }

（三）连接到对等 socket：connect()

客户端使用 connect 发起 TCP 连接：

struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
// 服务器 IPv4 地址（如 127.0.0.1）
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); 
server_addr.sin_port = htons(8080);if (connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {perror("connect");return 1;
}

• inet_addr：将 IPv4 字符串转换为网络字节序地址。

（四）流 socket I/O

使用 read/write 或 send/recv 进行数据传输：

// 服务器发送数据
char msg[] = "Hello Client";
send(client_sock, msg, sizeof(msg), 0);// 客户端接收数据
char buf[100];
recv(sock, buf, sizeof(buf), 0);

（五）连接终止：close()

关闭套接字，终止连接：

close(client_sock); // 关闭客户端连接
close(sock); // 关闭监听套接字

六、数据报 socket（UDP）

（一）交换数据报：recvfrom 和 sendto

UDP 是无连接协议，使用 sendto 发送数据报，recvfrom 接收数据报：

发送数据报（客户端）

struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
server_addr.sin_port = htons(8080);char msg[] = "UDP Packet";
// 发送数据报
sendto(sock, msg, sizeof(msg), 0, (struct sockaddr*)&server_addr, sizeof(server_addr)); 

接收数据报（服务器）

struct sockaddr_in client_addr;
socklen_t addrlen = sizeof(client_addr);
char buf[100];
// 接收数据报，同时获取客户端地址
ssize_t len = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr*)&client_addr, &addrlen); 
buf[len] = '\0';
printf("Received: %s\n", buf);

（二）在数据报 socket 上使用 connect()

UDP 也可调用 connect，绑定到固定服务器地址，后续 send/recv 无需重复指定地址：

// 绑定服务器地址
connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr)); 
// 直接发送，无需指定地址
send(sock, msg, sizeof(msg), 0); 
// 直接接收，仅来自绑定地址的数据
recv(sock, buf, sizeof(buf), 0); 

适合与固定服务器通信的场景（如 DNS 查询 ）。

七、总结

socket允许在同一主机或通过一个网络连接起来的不同主机上的应用程序之间通信。

一个socket存在于一个通信domain中，通信domain确定了通信范围和用来标识socket的地址格式。SUSv3规定了UNIX（AF_UNIX）、IPv4（AF_INET）以及IPv6（AF_INET6）通信domain。

大多数应用程序使用流socket和数据报socket中的一种。流socket（SOCK_STREAM）为两个端之间提供了一颗可靠的、双向的字节流通信信道。数据报socket（SOCK_DGRAM）提供了不可靠的、无连接的、面向消息的通信。

一个典型的流socket服务器会使用socket()创建其socket，然后使用bind()将这个socket绑定到一个众所周知的地址上。服务器接着调用listen()以允许在该socket上接受连接。监听socket上的客户端连接是通过accept()来接受的，它将返回一个与客户端的socket进行连接的新socket的文件描述符。一个典型的流socket客户端会使用socket()创建一个socket，然后通过调用connect()建立一个连接并制定服务器的众所周知的地址。当两个流socket连接之后就可以使用read()和write()在任意一个方向上传输数据了。一旦拥有引用一个流socket端点的文件描述符的所有进程都执行了一个隐式或显示的close()之后，连接就会终止。

一个典型的数据报socket服务器会使用socket()创建一个socket，然后使用bind()将其绑定到一个众所周知的地址上。由于数据报socket是无连接的，因此服务器的socket可以用来接收任意客户端的数据报。使用read()或socket特定的recvfrom()系统调用能够接收数据报，其中recvfrom()能够返回发送socket的地址。一个数据报socket客户端会使用socket()创建一个socket，然后使用sendto()将一个数据报发送到指定的（即服务器的）地址上。connect()系统调用可以用来为数据报socket设定一个对等地址。在设定完对等地址之后就无需为发出去的数据报指定目标地址了；write()调用可以用来发送一个数据报。

Socket 是网络编程的基石，支撑 TCP、UDP 等协议的通信：

• TCP（流套接字 ）：可靠、面向连接，适合文件传输、Web 服务等场景。
• UDP（数据报套接字 ）：无连接、低延迟，适合实时通讯、广播等场景。

掌握 socket、bind、listen、accept、connect 等核心 API，结合地址结构体与 I/O 操作，可构建客户端-服务器模型、实现跨主机数据交互。在实际开发中，需注意网络字节序转换、错误处理（如连接超时 ）、并发模型（如多线程/IO 多路复用 ），让网络应用更高效、更健壮。

UNIX Domain Socket 详解：本地进程通信的高效方案

在 Linux 系统中，除了网络 Socket 用于跨主机通信，UNIX Domain Socket（UDS）专注于同一主机的进程间通信，凭借高效、可靠的特性，成为本地进程协作的优选。它避免了网络协议栈的开销，适合高并发、低延迟的本地场景。以下深入解析 UDS 的实现与应用。

一、UNIX domain socket 地址：struct sockaddr_un

（一）地址结构体定义

UDS 使用文件系统路径作为地址标识，核心结构体 sockaddr_un：

#include <sys/un.h>
struct sockaddr_un {sa_family_t sun_family; // 地址族，固定为 AF_UNIXchar sun_path[108];     // UNIX domain socket 路径
};

• sun_family：必须设为 AF_UNIX，标识 UDS 地址类型。
• sun_path：存储文件系统路径（如 "/tmp/my_socket" ），长度限制为 108 字节。

（二）地址使用示例

struct sockaddr_un addr;
addr.sun_family = AF_UNIX;
// 绑定到 /tmp/my_socket 路径
strcpy(addr.sun_path, "/tmp/my_socket"); 

UDS 地址对应文件系统中的一个实体，绑定前需确保路径未被占用（或通过 unlink 清理残留 ）。

二、UNIX domain 中的流 socket（SOCK_STREAM）

（一）流 socket 的特性

UDS 流 socket 类似 TCP，提供可靠、面向连接的字节流传输，适合需要有序、无丢包的场景（如本地服务通信 ）。

（二）通信流程示例（服务器-客户端）

服务器端

int sock = socket(AF_UNIX, SOCK_STREAM, 0);
struct sockaddr_un addr = {.sun_family = AF_UNIX};
strcpy(addr.sun_path, "/tmp/my_socket");// 绑定地址（若路径已存在，需先 unlink）
unlink(addr.sun_path);
bind(sock, (struct sockaddr*)&addr, sizeof(addr));listen(sock, 5); // 监听连接struct sockaddr_un client_addr;
socklen_t addrlen = sizeof(client_addr);
// 接受客户端连接
int client_sock = accept(sock, (struct sockaddr*)&client_addr, &addrlen); char buf[100];
// 接收数据
read(client_sock, buf, sizeof(buf));
printf("Received: %s\n", buf);close(client_sock);
close(sock);
unlink(addr.sun_path); // 清理路径

客户端

int sock = socket(AF_UNIX, SOCK_STREAM, 0);
struct sockaddr_un addr = {.sun_family = AF_UNIX};
strcpy(addr.sun_path, "/tmp/my_socket");// 连接服务器
connect(sock, (struct sockaddr*)&addr, sizeof(addr));// 发送数据
write(sock, "Hello UDS", 9);close(sock);

流 socket 确保数据按序到达，且支持双向通信，适合本地服务（如 Docker 守护进程与客户端 ）。

三、UNIX domain 中的数据报 socket（SOCK_DGRAM）

（一）数据报 socket 的特性

UDS 数据报 socket 类似 UDP，提供无连接、不可靠的消息传输，适合低延迟、允许丢包的场景（如日志广播 ）。

（二）通信流程示例（发送-接收）

接收端

int sock = socket(AF_UNIX, SOCK_DGRAM, 0);
struct sockaddr_un addr = {.sun_family = AF_UNIX};
strcpy(addr.sun_path, "/tmp/udp_socket");unlink(addr.sun_path);
bind(sock, (struct sockaddr*)&addr, sizeof(addr));char buf[100];
struct sockaddr_un sender_addr;
socklen_t addrlen = sizeof(sender_addr);
// 接收数据报
ssize_t len = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sender_addr, &addrlen);
buf[len] = '\0';
printf("Received: %s from %s\n", buf, sender_addr.sun_path);close(sock);
unlink(addr.sun_path);

发送端

int sock = socket(AF_UNIX, SOCK_DGRAM, 0);
struct sockaddr_un addr = {.sun_family = AF_UNIX};
strcpy(addr.sun_path, "/tmp/udp_socket");// 发送数据报
sendto(sock, "UDS Datagram", 12, 0, (struct sockaddr*)&addr, sizeof(addr));close(sock);

数据报 socket 无需建立连接，支持一对多广播，适合本地事件通知（如系统日志转发 ）。

四、UNIX domain socket 权限

UDS 地址对应文件系统的路径，其权限由文件系统控制。通过 bind 时的 mode（或创建路径时的权限 ），可限制进程访问：

// 绑定地址时设置权限（仅当前用户可读写）
bind(sock, (struct sockaddr*)&addr, sizeof(addr));
// 或通过 chmod 修改路径权限
chmod("/tmp/my_socket", 0600); 

权限控制确保敏感通信（如密码管理器与浏览器 ）的安全性。

五、创建互联 socket 对：socketpair()

（一）socketpair 的作用

socketpair 创建一对互联的 socket，无需路径绑定，适合父子进程、线程间的高效通信。

（二）使用示例（父子进程通信）

int sv[2];
// 创建流式互联 socket 对
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) { perror("socketpair");return 1;
}if (fork() == 0) { // 子进程close(sv[0]); // 关闭父进程端write(sv[1], "Hello Parent", 12);close(sv[1]);
} else { // 父进程close(sv[1]); // 关闭子进程端char buf[100];read(sv[0], buf, sizeof(buf));printf("Parent received: %s\n", buf);close(sv[0]);wait(NULL);
}

socketpair 避免了路径管理，适合进程/线程间的轻量级通信（如 Chrome 进程间通信 ）。

六、Linux 抽象 socket 名空间

（一）抽象名空间的特性

Linux 支持抽象名空间的 UDS，地址不以文件系统路径存在，而是一个字符串标识符（如 "\0my_abstract_socket" ），前缀为 \0。

（二）使用示例

struct sockaddr_un addr;
addr.sun_family = AF_UNIX;
// 抽象名空间地址（首字节为 0）
strcpy(addr.sun_path, "\0my_abstract_socket"); // 绑定抽象地址（无需 unlink，不占用文件系统路径）
bind(sock, (struct sockaddr*)&addr, sizeof(addr.sun_family) + strlen(addr.sun_path));

抽象名空间避免了文件系统路径的残留问题，适合临时、高频的进程通信（如系统服务间通信 ）。

七、总结

UNIX domain socket允许位于同一主机上的应用程序之间进行通信。UNIX domain支持流和数据报socket。

UNIX domain socket是通过文件系统中的一个路径名来标识的。文件权限可以用来控制对UNIX domain socket的访问。

socketpair()系统调用创建一对相互连接的UNIX domain socket。这样就无需调用多个系统调用来创建、绑定以及连接socket。一个socket对的使用方式通常与管道类似：一个进程创建socket对，然后创建一个其引用socket对的描述符的子进程。然后这两个进程就能够通过这个socket对进行通信了。

Linux特有的抽象socket名空间允许将一个UNIX domain socket绑定到一个不存在于文件系统中的名字上。

UNIX Domain Socket 是本地进程通信的高效方案，覆盖流、数据报两种模式：

• 流 socket：可靠连接，适合有序数据传输（如本地 RPC ）。
• 数据报 socket：无连接，适合低延迟、广播场景（如日志分发 ）。

配合 sockaddr_un 地址结构体、权限控制、抽象名空间，UDS 满足不同场景的需求：

• 路径绑定的 UDS 适合服务化通信（如 systemd 套接字激活 ）。
• 抽象名空间的 UDS 适合临时、无残留的通信（如容器间协作 ）。
• socketpair 适合进程/线程的轻量级交互。

掌握 UDS 的特性与 API，可替代管道、共享内存等 IPC 方式，实现更高效、更灵活的本地进程协作，尤其在高并发、低延迟场景（如数据库、容器运行时 ）中发挥关键作用。

Socket 之 TCP/IP 网络基础：构建网络通信的底层逻辑

网络通信的实现依赖于 TCP/IP 协议族的层层协作，从物理网络的信号传输到应用层的数据交互，每一层都承担着特定职责。理解 TCP/IP 网络基础，是掌握 Socket 编程、实现稳定网络通信的前提。本文将逐层解析 TCP/IP 协议栈，梳理网络通信的核心原理。

一、因特网

（一）因特网的本质

因特网是全球互联的计算机网络集合，通过 TCP/IP 协议族实现不同网络、设备间的通信。它打破了地域和网络类型的限制，让家庭电脑、服务器、移动设备等能相互交换数据，是现代网络应用（如 Web、即时通讯 ）的基础载体。

（二）关键组成

• 终端设备：包括电脑、手机、物联网设备等，是数据的产生和消费端。
• 网络设备：路由器、交换机等，负责数据的转发和路由选择，保障数据包从源端到达目的端。
• 协议族：TCP/IP 协议族定义了数据的格式、传输规则，确保不同设备间“语言互通”。

二、联网协议和层

（一）OSI 参考模型与 TCP/IP 模型

为了规范网络通信流程，有 OSI（开放系统互联 ）7 层参考模型，但实际应用中广泛采用TCP/IP 4 层模型（或简化为 5 层 ），各层职责清晰：

• 应用层：提供应用程序接口（如 HTTP、FTP ），处理具体业务数据。
• 传输层：负责端到端的通信，实现数据的可靠（TCP ）或快速（UDP ）传输。
• 网络层：处理网络间的数据包路由，决定数据的传输路径（核心协议是 IP ）。
• 数据链路层：负责物理网络的帧传输，处理网卡、以太网等底层细节。
• 物理层：涉及物理介质（如网线、无线频谱 ）的信号传输，是网络通信的硬件基础。

TCP/IP 模型各层相互协作，将应用数据逐层封装、传输、解封装，实现跨网络通信。

（二）层间协作示例

以访问网页（HTTP ）为例：

1. 应用层：浏览器生成 HTTP 请求数据。
2. 传输层：TCP 协议为数据分段，添加端口等信息，确保可靠传输。
3. 网络层：IP 协议为数据添加源和目的 IP 地址，确定传输路径。
4. 数据链路层：将 IP 数据包封装为以太网帧，通过物理网络发送。
5. 物理层：将帧转换为电信号或光信号，在物理介质（如光纤 ）传输。

接收端则按相反流程，逐层解封装数据，最终交给应用层处理。

三、数据链路层

（一）核心功能

数据链路层负责相邻网络设备间的帧传输，主要工作包括：

• 帧封装：将网络层的 IP 数据包封装为帧，添加帧头（包含源和目的 MAC 地址 ）、帧尾（用于校验 ）。
• 介质访问控制：解决多设备共享物理介质的冲突问题（如以太网的 CSMA/CD ）。
• 差错检测：通过 CRC（循环冗余校验 ）检测帧在传输中的错误，若发现错误则丢弃或重传。

常见的数据链路层协议有以太网协议（Ethernet ）、Wi - Fi 协议（802.11 ）等。

（二）MAC 地址

MAC 地址是数据链路层的设备标识，是全球唯一的 48 位标识符（如 00:1A:2B:3C:4D:5E ），由网卡厂商分配。它用于在局域网内定位设备，网络层的 IP 地址则负责跨网络的路由，二者通过 ARP（地址解析协议 ）关联：将 IP 地址转换为 MAC 地址，实现数据链路层的准确传输。

四、网络层：IP

（一）IP 协议的作用

网络层的 IP 协议（主要是 IPv4 和 IPv6 ）负责跨网络的数据包路由，核心功能：

• 地址标识：为设备分配 IP 地址（如 IPv4 的 32 位地址、IPv6 的 128 位地址 ），区分不同网络中的设备。
• 数据包转发：通过路由表选择数据包的传输路径，将数据包从源网络转发到目的网络。
• 分片与重组：当数据包大小超过传输介质的 MTU（最大传输单元 ）时，将其分片传输，在目的端重组。

IP 协议提供无连接、不可靠的服务，不保证数据包的到达顺序和完整性，这些由传输层的 TCP 协议补充。

（二）IPv4 与 IPv6

• IPv4：32 位地址，格式为点分十进制（如 192.168.1.1 ），地址资源逐渐枯竭，面临地址不足问题。
• IPv6：128 位地址，格式为冒分十六进制（如 2001:0db8:85a3:0000:0000:8a2e:0370:7334 ），提供海量地址，解决 IPv4 地址短缺问题，同时优化了路由、安全性等特性。

目前网络处于 IPv4 向 IPv6 过渡阶段，很多网络同时支持两种协议（双栈 ）。

五、IP 地址

（一）IP 地址的分类与作用

IP 地址用于标识网络中的设备，分为：

• 公网 IP：全球唯一，可直接在因特网访问（如服务器的公网地址 ）。
• 私网 IP：局域网内使用，需通过 NAT（网络地址转换 ）访问公网（如家庭路由器分配的 192.168.x.x 地址 ）。

IP 地址还包含网络位和主机位（通过子网掩码划分 ），用于确定设备所属网络和在网络内的标识。

（二）地址解析：ARP 与 DNS

• ARP：将 IP 地址转换为 MAC 地址，实现数据链路层的设备定位，如局域网内设备通信时，通过 ARP 找到对方的 MAC 地址。
• DNS：将域名（如 www.example.com ）转换为 IP 地址，是应用层常用的地址解析服务，让用户无需记忆复杂的 IP 地址即可访问网络服务。

六、传输层

（一）传输层的职责

传输层负责端到端的通信保障，为应用层提供稳定的传输服务，主要协议有 TCP 和 UDP 。

（二）端口号

端口号是传输层的“应用标识”，16 位整数（范围 0 - 65535 ），用于区分同一设备上的不同应用程序。分为：

• 知名端口：0 - 1023，分配给系统服务（如 HTTP 的 80 端口、HTTPS 的 443 端口 ）。
• 动态端口：1024 - 65535，供应用程序动态使用（如客户端程序的临时端口 ）。

通过 IP 地址 + 端口号的组合（套接字地址 ），实现不同设备上应用程序的准确通信。

（三）用户数据报协议（UDP）

UDP 是无连接、不可靠的传输协议，特点：

• 高效快速：无需建立连接、确认机制，开销小，适合实时性要求高的场景（如视频通话、DNS 查询 ）。
• 不保证可靠性：不确保数据包到达、有序，可能丢包、乱序，需应用层自己处理可靠性逻辑。

UDP 的数据传输单元是数据报，每个数据报独立传输，常用于对延迟敏感、能容忍少量丢包的应用。

（四）传输控制协议（TCP）

TCP 是面向连接、可靠的传输协议，核心特性：

• 连接建立：通过三次握手建立连接，确保通信双方就绪。
• 可靠传输：采用序号、确认应答、重传机制，保证数据有序、完整到达。
• 流量控制：通过滑动窗口机制，根据接收方能力调整发送速率，避免拥塞。
• 拥塞控制：检测网络拥塞，动态调整发送窗口，保障网络整体性能。

TCP 适合对可靠性要求高的场景（如文件传输、网页浏览 ），但因连接建立和确认机制，开销相对 UDP 较大。

七、请求注解（RFC）

RFC（Request For Comments，请求注解 ）是互联网工程任务组（IETF ）发布的技术文档，定义了 TCP/IP 协议族的标准和规范。从 IP 地址格式到 TCP 拥塞控制算法，几乎所有网络协议的细节都在 RFC 中详细描述。例如：

• RFC 791：定义 IPv4 协议。
• RFC 793：定义 TCP 协议。
• RFC 826：定义 ARP 协议。

开发者和网络工程师可通过查阅 RFC，深入了解协议细节，解决复杂网络问题或参与协议的改进。

八、总结

TCP/IP是一个分层的联网协议条件。在TCP/IP协议栈的最底层是IP网络层协议。IP以数据报的形式传输数据。IP是无连接的，表示在源主机和目的主机之间传输的数据报可能经过网络中的不同路径。IP是不可靠的，因为它不保证数据报会按序以及不重复到达，甚至还不保证数据报一定会到达。如果要求可靠性的话就必须要通过使用一个可靠的高层协议（如TCP）或在应用程序中来完成。

IP最初的版本是IPv4。在20世纪90年代早期，IP的一个新版本IPv6被设计出来了。IPv4和IPv6之间最显著的差别在于IPv4使用了32位来表示一个主机地址，而IPv6则使用了128位，从而允许在全球范围的因特网中接入更多的主机。目前，IPv4仍然是使用最为广泛的IP，尽管在将来可能会被IPv6所取代。

在IP之上存在多种传输层协议，其中使用最多的是UDP和TCP。UDP是一个不可靠的数据报协议。TCP是一个可靠的、面向连接的字节流协议。TCP处理了连接建立和终止的所有细节。TCP还将数据打包成分段以供IP传输并为这些分段提供了序号计数，这样接收者就能对这些分段进行确认并以正确的顺序组装这些分段。此外，TCP还提供了流量控制来防止一个快速的发送者压垮一个慢速的接收者和拥塞控制来防止一个快速的发送者压垮整个网络。

TCP/IP 网络基础是 Socket 编程的底层支撑，各层协议协同工作：

• 数据链路层：保障局域网内的帧传输，处理物理介质交互。
• 网络层（IP ）：实现跨网络的数据包路由，定位设备地址。
• 传输层（TCP/UDP ）：提供端到端的通信服务，选择可靠或高效的传输方式。
• 应用层：面向具体应用，定义数据交互的格式和逻辑。

理解 TCP/IP 协议栈的分层职责、协议特性（如 TCP 的可靠、UDP 的高效 ），是设计高性能网络应用的关键。无论是开发 Web 服务器、即时通讯工具，还是优化网络性能，掌握这些基础原理都能让你更精准地驾驭网络通信，应对复杂的网络环境挑战。

Internet Domain Socket 深度解析：构建网络通信的关键环节

在网络编程中，Internet Domain Socket 是实现跨主机通信的核心工具，它依托 TCP/IP 协议族，让不同网络中的进程能够交换数据。从地址处理到数据传输，每一步都关乎通信的稳定性与效率。本文将全面拆解 Internet Domain Socket 的关键知识点，带你掌握网络通信的实战逻辑。

一、Internet domain socket 基础

（一）核心定义与作用

Internet domain socket（互联网域套接字 ）基于 AF_INET（IPv4 ）或 AF_INET6（IPv6 ）地址族，用于跨网络的进程通信。它突破了本地通信的限制，让云服务器与用户设备、不同地域的服务器之间能够交换数据，是 Web 服务、即时通讯、文件传输等应用的底层支撑。

（二）与 UNIX Domain Socket 的差异

与专注本地通信的 UNIX Domain Socket 不同，Internet domain socket 依赖网络协议栈（如 TCP/IP ），需处理网络延迟、丢包、地址转换等问题。其地址使用 IP 地址 + 端口号的形式，而非文件系统路径。

二、网络字节序

（一）字节序的问题

不同计算机的 CPU 可能采用不同的字节序：

• 大端序（Big - Endian）：高位字节存于低地址（如网络协议默认使用 ）。
• 小端序（Little - Endian）：低位字节存于低地址（如 x86 架构 CPU ）。

网络通信中，需统一使用网络字节序（大端序），否则会出现数据解析错误（如端口号、IP 地址错乱 ）。

（二）转换函数

• htons/ntohs：主机字节序与网络字节序的 16 位（端口号 ）转换。
• htonl/ntohl：主机字节序与网络字节序的 32 位（IP 地址 ）转换。

示例：将端口号转换为网络字节序

uint16_t port = 8080;
uint16_t net_port = htons(port);

三、数据表示

（一）网络数据的格式化

网络通信中，数据需按网络协议规定的格式组织。例如：

• TCP 数据包需包含源/目的端口、序列号、确认号等字段。
• 应用层协议（如 HTTP ）需按文本或二进制格式组织请求/响应数据。

开发者需明确数据的编码、长度、分隔符等规则，避免通信双方因数据格式不一致导致解析失败。

（二）二进制与文本数据

• 二进制数据：高效紧凑，适合传输文件、协议头（如图片、视频 ），需注意字节序和长度字段。
• 文本数据：可读性强，适合协议交互（如 HTTP、SMTP ），但需处理编码（如 UTF - 8 ）和转义问题。

四、Internet socket 地址

（一）地址结构体

IPv4 地址结构体（sockaddr_in）

struct sockaddr_in {sa_family_t sin_family; // AF_INETin_port_t sin_port;     // 端口（网络字节序）struct in_addr sin_addr; // IPv4 地址（网络字节序）
};struct in_addr {uint32_t s_addr; // IPv4 地址（如 0x7F000001 对应 127.0.0.1）
};

IPv6 地址结构体（sockaddr_in6）

struct sockaddr_in6 {sa_family_t sin6_family; // AF_INET6in_port_t sin6_port;     // 端口（网络字节序）uint32_t sin6_flowinfo;  // 流信息struct in6_addr sin6_addr; // IPv6 地址uint32_t sin6_scope_id;  // 范围 ID（用于链路本地地址）
};

（二）地址使用示例

绑定 IPv4 地址到 socket：

struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(8080);
// 绑定到本地回环地址
addr.sin_addr.s_addr = inet_addr("127.0.0.1"); 
bind(sock, (struct sockaddr*)&addr, sizeof(addr));

五、主机和服务转换函数概述

（一）核心需求

网络通信中，常需将域名转换为 IP 地址（如 www.example.com → 93.184.216.34 ），或端口号转换为服务名（如 80 → HTTP ）。主机和服务转换函数解决这些问题，屏蔽底层协议细节。

六、inet_pton() 和 inet_ntop() 函数

（一）函数功能

• inet_pton：将 IPv4/IPv6 字符串（如 "192.168.1.1"、"2001:db8::1" ）转换为网络字节序的二进制地址。
• inet_ntop：将二进制地址转换为字符串形式，便于显示和调试。

（二）示例：地址转换

// IPv4 字符串转二进制
struct in_addr addr;
inet_pton(AF_INET, "192.168.1.1", &addr);// 二进制转字符串
char buf[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &addr, buf, sizeof(buf));
printf("IP: %s\n", buf); // 输出 192.168.1.1

七、客户端-服务器示例（数据报 socket）

（一）UDP 通信流程

服务器端（接收数据报）

int sock = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in addr = {.sin_family = AF_INET, .sin_port = htons(8080)};
bind(sock, (struct sockaddr*)&addr, sizeof(addr));struct sockaddr_in client_addr;
socklen_t addrlen = sizeof(client_addr);
char buf[100];
// 接收客户端数据报
ssize_t len = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr*)&client_addr, &addrlen);
buf[len] = '\0';
printf("Received: %s\n", buf);close(sock);

客户端（发送数据报）

int sock = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in server_addr = {.sin_family = AF_INET, .sin_port = htons(8080), .sin_addr.s_addr = inet_addr("127.0.0.1")};sendto(sock, "Hello UDP", 9, 0, (struct sockaddr*)&server_addr, sizeof(server_addr));close(sock);

UDP 无需建立连接，适合低延迟、广播场景，但需处理丢包和乱序问题。

八、域名系统（DNS）

（一）DNS 的作用

DNS（域名系统 ）是分布式域名解析服务，将域名（如 www.example.com ）转换为 IP 地址，让用户无需记忆复杂的 IP 地址即可访问网络服务。它通过根服务器、顶级域名服务器、权威域名服务器的层级结构，实现高效的域名解析。

（二）DNS 解析流程

1. 客户端向本地 DNS 服务器发送域名查询请求。
2. 本地 DNS 服务器递归查询根服务器、顶级域名服务器、权威服务器，获取 IP 地址。
3. 将解析结果返回给客户端，客户端通过 IP 地址建立连接。

（三）编程中的 DNS 解析

通过 getaddrinfo 函数可实现编程中的 DNS 解析（见下文 getaddrinfo 介绍 ），自动处理域名到 IP 地址的转换。

九、/etc/services 文件

（一）文件作用

/etc/services 是系统级服务端口映射文件，记录服务名与端口号、协议的对应关系（如 http 80/tcp、https 443/tcp ）。它用于：

• 解析服务名到端口号（如将 http 转换为 80 端口 ）。
• 规范系统服务的端口使用，避免冲突。

（二）编程中的应用

通过 getservbyname 等函数，可查询 services 文件，动态获取服务端口：

struct servent *serv = getservbyname("http", "tcp");
if (serv) {printf("HTTP 端口：%d\n", ntohs(serv->s_port)); // 输出 80
}

十、独立于协议的主机和服务转换

（一）getaddrinfo() 函数

getaddrinfo 是协议无关的地址解析函数，支持 IPv4/IPv6，自动处理 DNS 解析和地址转换：

#include <netdb.h>struct addrinfo hints, *res;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // 支持 IPv4 和 IPv6
hints.ai_socktype = SOCK_STREAM; // TCP// 解析域名和服务名
int err = getaddrinfo("www.example.com", "http", &hints, &res); 
if (err) {fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(err));return 1;
}// 遍历解析结果
for (struct addrinfo *p = res; p != NULL; p = p->ai_next) {// 创建 socket 并连接...
}freeaddrinfo(res); // 释放资源

（二）freeaddrinfo()、gai_strerror()、getnameinfo()

• freeaddrinfo：释放 getaddrinfo 分配的内存。
• gai_strerror：将 getaddrinfo 的错误码转换为字符串，便于调试。
• getnameinfo：将二进制地址转换为域名和服务名（反向解析 ）：

  char host[NI_MAXHOST], serv[NI_MAXSERV];
  getnameinfo(p->ai_addr, p->ai_addrlen, host, sizeof(host), serv, sizeof(serv), 0);
  printf("Host: %s, Service: %s\n", host, serv);
  

十一、客户端-服务器示例（流式 socket）

（一）TCP 通信流程

服务器端（监听并接受连接）

int sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr = {.sin_family = AF_INET, .sin_port = htons(8080)};
bind(sock, (struct sockaddr*)&addr, sizeof(addr));
listen(sock, 5);struct sockaddr_in client_addr;
socklen_t addrlen = sizeof(client_addr);
// 接受客户端连接
int client_sock = accept(sock, (struct sockaddr*)&client_addr, &addrlen); char buf[100];
read(client_sock, buf, sizeof(buf));
printf("Received: %s\n", buf);close(client_sock);
close(sock);

客户端（建立连接并发送数据）

int sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in server_addr = {.sin_family = AF_INET, .sin_port = htons(8080), .sin_addr.s_addr = inet_addr("127.0.0.1")};connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr));
write(sock, "Hello TCP", 9);close(sock);

TCP 提供可靠连接，适合文件传输、Web 服务等场景，但需处理连接建立、断开的开销。

十二、Internet domain socket 库与过时 API

（一）现代库与过时 API 的对比

现代网络编程推荐使用 getaddrinfo、inet_pton 等协议无关函数，替代过时的 inet_aton、gethostbyname 等 API：

• 过时 API：如 inet_aton（仅支持 IPv4 ）、gethostbyname（线程不安全 ），逐渐被弃用。
• 现代 API：getaddrinfo 支持 IPv4/IPv6，线程安全，更适合跨平台开发。

十三、UNIX 与 Internet domain socket 比较

特性	Internet Domain Socket	UNIX Domain Socket
通信范围	跨网络（不同主机）	本地（同一主机）
地址类型	IP 地址 + 端口号	文件系统路径或抽象名空间
协议依赖	TCP/IP 协议族	无需网络协议栈
典型场景	Web 服务、远程通信	本地进程协作（如 Docker 通信 ）
性能	依赖网络延迟，开销较高	本地通信，开销低

十四、总结

Internet domain socket允许位于不同主机上的应用程序通过一个TCP/IP网络进行通信。一个Internet domain socket地址由一个IP地址和一个端口号构成。在IPv4中，一个IP地址是一个32位的数字，在IPv6中则是一个128位的数字。Internet domain数据报socket运行于UDP上，它提供了无连接的、不可靠的、面向消息的通信。Internet domain流socket运行于TCP上，它为相互连接的应用程序提供了可靠的、双向字节流通信信道。

不同的计算机架构使用不同的方式来表示数据类型。如整数可以以小端形式存储也可以以大端形式存储，并且不同的计算机可能使用不同的字节数来表示诸如int和long之类的数值类型。这些差别意味着当在通过网络连接的异构机器之间传输数据时需要采用某种独立于架构的表示。本章指出了存在多种信号编集标准来解决这个问题，同时还描述了被很多应用程序所采用的一个简单的解决方案：将所有传输的数据编码成文本形式，字段之间使用预先指定的字符（通常是换行符）分隔。

本章介绍了一组用于在IP地址的（数值）字符串表示（IPv4是点分十进制，IPv6是十六进制字符串）和其二进制值之间进行转换的函数，然而一般来讲最好使用主机和服务名而不是数字，因为名字更容易记忆并且即使在对应的数字发生变化时也能继续使用。此外，还介绍了用于将主机和服务名转换成数值表示及其逆过程的各种函数。将主机和服务名转换成socket地址的现代函数是getaddrinfo()，但读者在既有代码中会经常看到早期的gethostbyname()和getservbyname()函数。

对主机名转换的思考引出了对DNS的讨论，它实现了一个分布式数据库提供层级目录服务。DNS的优点是数据库的管理不再是集中的了。相反，本地区域管理员可以更新他们所负责的数据库层级部分，并且DNS服务器可以与另一台服务器进行通信以便解析一个主机名。

Internet Domain Socket 是跨网络通信的核心工具，依托 TCP/IP 协议族实现进程间的数据交换：

• 地址与字节序：需处理网络字节序转换、IP 地址与域名的解析，确保通信双方地址正确。
• 协议选择：TCP 提供可靠连接，适合文件传输、Web 服务；UDP 提供高效传输，适合实时通讯。
• 现代 API：getaddrinfo 等函数简化了地址解析，提升了跨平台兼容性和开发效率。

掌握 Internet Domain Socket 的核心知识点，能让你在开发网络应用（如 Web 服务器、即时通讯工具 ）时，精准处理地址转换、数据传输等问题，构建稳定、高效的网络通信架构。无论是应对复杂的网络环境，还是优化应用性能，这些基础原理都是不可或缺的支撑。

Socket 服务器设计：打造高效稳定的网络服务

在网络应用中，服务器的设计直接决定了服务的性能、并发能力和稳定性。基于 Socket 的服务器，需根据业务需求选择合适的架构（迭代型或并发型 ），处理高并发、高可靠的网络请求。本文将深入解析服务器设计的核心模式，从基础实现到高级优化，带你构建高效的 Socket 服务器。

一、迭代型和并发型服务器

（一）核心架构对比

迭代型服务器

• 原理：同一时间仅处理一个客户端请求，完成后再处理下一个。
• 优点：实现简单，适合请求少、处理快的场景（如 UDP 回声服务 ）。
• 缺点：无法处理高并发，客户端需排队等待。

并发型服务器

• 原理：通过多进程、多线程或 IO 多路复用，同时处理多个客户端请求。
• 优点：支持高并发，适合 Web 服务、即时通讯等场景。
• 缺点：实现复杂，需处理资源竞争、进程/线程管理等问题。

二、迭代型 UDP echo 服务器

（一）需求与流程

迭代型 UDP 服务器接收客户端数据报，直接回显（echo）给客户端，流程：

1. 创建 UDP Socket，绑定地址。
2. 循环：接收客户端数据报 → 回显数据报给客户端。

（二）代码实现

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cstring>
#include <iostream>using namespace std;int main() {// 创建 UDP Socketint sock = socket(AF_INET, SOCK_DGRAM, 0);if (sock == -1) {perror("socket");return 1;}// 绑定地址struct sockaddr_in addr;addr.sin_family = AF_INET;addr.sin_port = htons(8080);addr.sin_addr.s_addr = INADDR_ANY;if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) == -1) {perror("bind");close(sock);return 1;}char buf[1024];struct sockaddr_in client_addr;socklen_t client_addr_len = sizeof(client_addr);// 迭代处理请求while (true) {// 接收数据报ssize_t len = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr*)&client_addr, &client_addr_len);if (len == -1) {perror("recvfrom");continue;}// 回显数据报if (sendto(sock, buf, len, 0, (struct sockaddr*)&client_addr, client_addr_len) == -1) {perror("sendto");}}close(sock);return 0;
}

迭代型 UDP 服务器逻辑简单，但无法并行处理多个客户端，适合低并发场景。

三、并发型 TCP echo 服务器

（一）多线程实现方案

并发型 TCP 服务器通过多线程处理客户端连接，主线程负责监听，子线程处理客户端请求：

主线程（监听连接）

int main() {int listen_sock = socket(AF_INET, SOCK_STREAM, 0);// 绑定、监听...while (true) {struct sockaddr_in client_addr;socklen_t client_addr_len = sizeof(client_addr);// 接受客户端连接int client_sock = accept(listen_sock, (struct sockaddr*)&client_addr, &client_addr_len); if (client_sock == -1) {perror("accept");continue;}// 创建线程处理客户端pthread_t tid;pthread_create(&tid, NULL, handle_client, (void*)&client_sock);pthread_detach(tid); // 分离线程，自动回收资源}close(listen_sock);return 0;
}

子线程（处理请求）

void* handle_client(void* arg) {int client_sock = *(int*)arg;char buf[1024];// 循环读取并回显数据while (true) {ssize_t len = read(client_sock, buf, sizeof(buf));if (len <= 0) { // 客户端断开或出错break;}write(client_sock, buf, len);}close(client_sock);return NULL;
}

（二）优缺点分析

• 优点：通过线程并行处理客户端，支持高并发。
• 缺点：线程创建开销大，大量线程可能导致资源耗尽（可通过线程池优化 ）。

四、并发型服务器的其他设计方案

（一）多进程服务器

通过 fork 创建子进程处理客户端，原理与多线程类似，但进程间资源隔离更严格，适合高安全需求场景。

示例（简化版）

while (true) {int client_sock = accept(listen_sock, ...);if (fork() == 0) { // 子进程close(listen_sock); // 关闭监听套接字handle_client(client_sock); // 处理请求close(client_sock);exit(0); // 子进程退出} else { // 父进程close(client_sock); // 关闭客户端套接字}
}

（二）IO 多路复用（select/poll/epoll）

通过 epoll（Linux 特有 ）等机制，单线程管理多个客户端连接，避免线程/进程开销，适合超高并发场景（如 Nginx ）。

epoll 示例（简化版）

int epfd = epoll_create(1);
struct epoll_event event, events[1024];
event.data.fd = listen_sock;
event.events = EPOLLIN;
epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &event);while (true) {int nfds = epoll_wait(epfd, events, 1024, -1);for (int i=0; i<nfds; i++) {if (events[i].data.fd == listen_sock) { // 新连接int client_sock = accept(listen_sock, ...);event.data.fd = client_sock;event.events = EPOLLIN;epoll_ctl(epfd, EPOLL_CTL_ADD, client_sock, &event);} else { // 客户端数据int client_sock = events[i].data.fd;char buf[1024];ssize_t len = read(client_sock, buf, sizeof(buf));// 处理数据...}}
}

（三）优缺点对比

方案	优点	缺点
多线程	实现简单，资源共享方便	线程开销大，竞争风险高
多进程	隔离性好，安全稳定	进程开销大，通信复杂
IO 多路复用	高效处理高并发，资源开销小	实现复杂，需处理事件循环

五、inetd（Internet 超级服务器）守护进程

（一）inetd 的作用

inetd 是系统守护进程，统一管理多个网络服务（如 Telnet、FTP ）：

• 监听多个端口，收到连接后派生子进程执行对应服务（如启动 telnetd ）。
• 减少服务进程的资源占用（无需每个服务单独监听端口 ）。

（二）配置与原理

通过 /etc/inetd.conf 配置服务映射：

echo    stream  tcp     nowait  root    /bin/echo  echo

• echo：服务名。
• stream：TCP 流服务。
• nowait：不等待子进程退出（适合并发场景 ）。

inetd 监听端口，收到连接后自动启动 /bin/echo 处理请求。

六、总结

迭代型服务器一次只处理一个客户端，在处理下一个客户端请求之前必须将当前客户端的请求处理完毕。并发型服务器可以同时处理多个客户端请求。在高负载的情况下，传统的并发型服务器为每个客户端创建新的子进程（或线程），这样的性能表现并不能达到要求。为此，我们针对需要同时处理大量客户端的并发型服务器，列举出了一些其他的设计方法。

Internet超级服务器守护进程inetd可以监视多个套接字，并启动合适的服务器进程作为到来的UDP数据报或TCP连接的响应。通过使用inetd，可以将运行在系统上的网络服务进程的数量降到最小，从而降低系统的整体负载。同时，也可以简化服务器端的编程工作。因为服务器进程初始化阶段所需要的大部分操作inetd都可以帮我们完成。

Socket 服务器设计需根据业务需求选择架构：

• 迭代型：简单易实现，适合低并发、短请求场景（如 UDP 回声服务 ）。
• 并发型：
  • 多线程/多进程：通过并行处理提升并发，适合中等规模请求。
  • IO 多路复用：高效处理超高并发，适合 Web 服务器、网关等场景。
• inetd：简化服务管理，适合系统级基础服务。

在实际开发中，需结合性能、复杂度、资源开销选择方案。例如，小型服务可用多线程，大型高并发服务首选 IO 多路复用。掌握服务器设计的核心模式，能让你构建稳定、高效的网络服务，应对不同场景的需求。

Socket 高级主题：深入网络通信底层

在掌握 Socket 基础编程后，深入理解其高级特性是优化网络应用、解决复杂问题的关键。从流式套接字的 I/O 细节，到 TCP 协议的深度剖析，再到高级功能扩展，每一项都关乎应用的性能与稳定性。本文将逐一拆解这些高级主题，带你吃透 Socket 编程的精髓。

一、流式套接字上的部分读和部分写

（一）现象与原因

在 TCP 流式套接字中，read/write 不一定一次性完成全部数据的读写，即部分读/写：

• 部分读：缓冲区有数据但不足请求长度，read 返回实际读取的字节数。
• 部分写：缓冲区满或内核限制，write 仅写入部分数据，需循环重试。

这是因为 TCP 是流式协议，无消息边界，且受内核缓冲区、网络拥塞等影响。

（二）处理示例

ssize_t full_read(int sock, void *buf, size_t len) {size_t remaining = len;char *p = (char*)buf;while (remaining > 0) {ssize_t n = read(sock, p, remaining);if (n == -1) {if (errno == EINTR) continue; // 中断重试return -1;}if (n == 0) break; // 连接关闭p += n;remaining -= n;}return len - remaining;
}ssize_t full_write(int sock, const void *buf, size_t len) {size_t remaining = len;const char *p = (const char*)buf;while (remaining > 0) {ssize_t n = write(sock, p, remaining);if (n == -1) {if (errno == EINTR) continue;return -1;}p += n;remaining -= n;}return len;
}

通过循环读写，确保数据完整传输。

二、shutdown() 系统调用

（一）与 close() 的区别

• close()：关闭套接字描述符，若为最后一个引用，终止双向通信。
• shutdown()：更灵活，可单向关闭通信（如仅关闭写端，保留读端 ）。

函数原型：

int shutdown(int sockfd, int how);

• how：SHUT_RD（关闭读 ）、SHUT_WR（关闭写 ）、SHUT_RDWR（关闭双向 ）。

（二）应用场景

• 优雅关闭连接：先 shutdown(SHUT_WR) 发送 FIN 包，继续读取剩余数据，再 close。
• 避免 TIME_WAIT 阻塞：配合 SHUT_RDWR 快速释放端口（需结合协议设计 ）。

三、专用于套接字的 I/O 系统调用：recv() 和 send()

（一）与 read()/write() 的差异

recv/send 支持标志位，扩展 I/O 控制：

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

• flags：如 MSG_PEEK（查看数据不消费 ）、MSG_OOB（带外数据 ）。

（二）示例：查看数据不消费

char buf[100];
// 查看数据，不从缓冲区移除
recv(sock, buf, sizeof(buf), MSG_PEEK); 
// 再次读取，仍能获取相同数据
recv(sock, buf, sizeof(buf), 0); 

四、sendfile() 系统调用

（一）零拷贝原理

sendfile 实现零拷贝传输，直接在内核空间传递文件数据，避免用户态与内核态的拷贝开销：

ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);

• out_fd：套接字描述符（输出 ）。
• in_fd：文件描述符（输入 ）。

（二）应用场景

高效传输大文件（如 Web 服务器发送静态资源 ），显著提升性能。示例：

int file_fd = open("large_file.txt", O_RDONLY);
// 直接发送文件内容到客户端
sendfile(client_sock, file_fd, NULL, file_size); 
close(file_fd);

五、获取套接字地址

（一）函数与应用

通过 getsockname（获取本地地址 ）和 getpeername（获取对端地址 ），调试网络连接：

struct sockaddr_storage local, peer;
socklen_t len = sizeof(local);
getsockname(sock, (struct sockaddr*)&local, &len);
getpeername(sock, (struct sockaddr*)&peer, &len);

用于日志记录、权限验证（如限制特定 IP 连接 ）。

六、深入探讨 TCP 协议

（一）TCP 报文的格式

TCP 报文包含首部和数据，首部字段：

• 源/目的端口、序列号、确认号、窗口大小、标志位（SYN、ACK、FIN 等 ）。

（二）TCP 序列号和确认机制

• 序列号：标识数据段的顺序，确保重组和去重。
• 确认号：期望收到的下一个序列号，实现可靠传输。

（三）TCP 协议状态机以及状态迁移图

TCP 连接经历 CLOSED → SYN_SENT → SYN_RECV → ESTABLISHED → FIN_WAIT_1 → TIME_WAIT 等状态，理解状态迁移是排查连接问题的关键。

（四）TCP 连接的建立（三次握手）

1. 客户端发送 SYN，进入 SYN_SENT。
2. 服务器回复 SYN+ACK，进入 SYN_RECV。
3. 客户端回复 ACK，进入 ESTABLISHED。

（五）TCP 连接的终止（四次挥手）

1. 主动方发送 FIN，进入 FIN_WAIT_1。
2. 被动方回复 ACK，进入 CLOSE_WAIT；主动方进入 FIN_WAIT_2。
3. 被动方发送 FIN，进入 LAST_ACK。
4. 主动方回复 ACK，进入 TIME_WAIT，确保被动方收到确认。

（六）在 TCP 套接字上调用 shutdown()

shutdown(SHUT_WR) 触发 FIN 包发送，用于半关闭连接；shutdown(SHUT_RD) 则不再接收数据。

（七）TIME_WAIT 状态

TIME_WAIT 持续 2MSL（最大分段生命周期 ），确保残留报文消失，避免干扰新连接。过多 TIME_WAIT 会占用端口，可通过 SO_REUSEADDR 优化。

七、监视套接字：netstat

（一）命令与输出

netstat 查看套接字状态：

netstat -anp | grep <port>

• 显示 ESTABLISHED（已建立 ）、TIME_WAIT（等待关闭 ）等状态，辅助排查连接泄漏、端口占用问题。

八、使用 tcpdump 来监视 TCP 流量

（一）抓包与分析

tcpdump 捕获网络报文，分析 TCP 交互：

tcpdump -i eth0 'tcp port 8080' -w traffic.pcap

结合 Wireshark 分析报文序列、重传、延迟等问题。

九、套接字选项

（一）setsockopt()/getsockopt()

配置套接字行为，如缓冲区大小、超时、地址复用：

int opt = 1;
// 允许地址复用
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); 

十、SO_REUSEADDR 套接字选项

（一）作用与场景

• 允许绑定已处于 TIME_WAIT 的端口，快速重启服务器。
• 解决 “地址已在使用” 错误，需在 bind 前设置。

十一、在 accept() 中继承标记和选项

（一）原理与应用

通过 setsockopt 设置的选项（如 SO_REUSEADDR ），可被 accept 后的新套接字继承，简化子连接配置。

十二、TCP vs UDP

（一）核心差异对比

特性	TCP	UDP
连接	面向连接	无连接
可靠性	可靠传输（确认、重传 ）	不可靠
开销	高（三次握手、确认 ）	低（无额外控制 ）
适用场景	文件传输、Web 服务	实时通讯、广播

十三、高级功能

（一）带外数据（Out - of - Band）

通过 MSG_OOB 发送紧急数据，用于中断、异常通知，需结合 SIGURG 信号处理。

（二）sendmsg() 和 recvmsg() 系统调用

支持复杂数据传输（如分散/聚集 I/O、控制信息 ），灵活处理多缓冲区、辅助数据：

struct msghdr msg;
// 填充消息头、数据缓冲区、控制信息
sendmsg(sock, &msg, 0); 

（三）传递文件描述符

通过 sendmsg/recvmsg 传递文件描述符（需结合 UNIX 域套接字 ），实现进程间高效通信。

（四）接收发送端的凭据

通过控制消息接收发送端的 UID、GID，用于权限验证（如服务端确认客户端身份 ）。

（五）顺序数据包套接字（SCTP）

SCTP 结合 TCP 可靠性与 UDP 多流特性，支持多宿主、消息边界，适合电信级应用。

（六）SCTP 以及 DCCP 传输层协议

• DCCP：数据报拥塞控制协议，提供不可靠但可拥塞控制的传输，适合流媒体等场景。

十四、总结

在许多情况下，当在流式套接字上执行I/O操作时会出现部分读取和部分写入的现象。我们给出了两个函数readn()以及writen()的实现，它们可用来确保将缓冲区中的数据完整地读取或写入。

shutdown()系统调用对连接终止提供了更加精细的控制。通过调用shutdown()，无论是否有其他打开的文件描述符指向套接字，我们都可以强行关闭双向通信流的其中一端或两端。

同read()和write()一样，recv()和send()也可用来在套接字上执行I/O操作，但需要提供一个额外的参数flags，该参数用来控制特定于套接字的I/O功能。

系统调用sendfile()允许我们高效地将文件内容拷贝到套接字上。获得高效性的原因在于我们不需要将文件数据在用户内存空间中来回拷贝，而read()和write()则需要这么处理。

系统调用getsockname()和getpeername()可以分别获取套接字绑定的本地地址以及连接的对端套接字地址。

我们对TCP协议的一些操作细节做了讨论，包括TCP的状态、TCP状态迁移图以及TCP连接的建立和终止。作为讨论的一部分，我们了解了为什么TIME_WAIT状态在TCP的可靠性保证中占据了重要的部分。尽管当重启服务器时，这个状态可以导致出现“地址已经使用”的错误。之后我们学习了SO_REUSEADDR套接字选项可用来避免出现这个错误，同时让TIME_WAIT状态达到其预期的目的。

netstat和tcpdump命令是用来监视和调试使用套接字的应用程序的优秀工具。

系统调用getsockopt()和setsockopt()可用来获取和修改影响套接字操作的相关选项。

在Linux上，当accept()调用返回一个新创建的套接字时，它并不会继承监听套接字上的与信号驱动I/O相关的打开文件状态标记、文件描述符标记以及文件描述符属性。但是，可以继承已设定的套接字选项。我们也提到了在SUSv3规范中，对于这些继承规则的细节并没有做说明，这些规则在不同的实现中有所不同。

尽管UDP没有提供TCP那样的可靠性保证，我们也了解到了对于某些应用程序来说为什么UDP是更加合适的选择。

最后，我们列出了一些套接字编程中的高级特性，本书并没有对此做详细的描述。

Socket 高级主题涵盖 I/O 细节、协议深度、性能优化等关键领域：

• 流式 I/O 处理：通过循环读写、sendfile 优化数据传输。
• TCP 协议剖析：理解三次握手、四次挥手、状态机，解决连接疑难。
• 高级功能扩展：利用套接字选项、sendmsg/recvmsg 实现复杂通信需求。

掌握这些内容，能让你在开发高性能网络应用时，精准优化传输效率、排查协议问题、扩展通信能力。无论是构建高并发服务器，还是调试复杂网络环境，这些知识都是不可或缺的底层支撑。