计算机网络 / 知识点
Socket API 常用调用速查
创建与连接
int socket(int domain, int type, int protocol);创建一个 Socket 文件描述符并选择地址族、通信类型与协议;TCP 服务通常使用 AF_INET 或 AF_INET6 配合 SOCK_STREAM,成功返回非负文件描述符。
创建 Socket
需要建立 TCP/UDP 通信端点时先调用 socket()。调用成功后得到一个可供 bind()、connect()、listen() 等 API 使用的文件描述符;失败时返回 -1,应立即读取 errno 对应的错误原因。
签名
int socket(int domain, int type, int protocol);头文件为 <sys/socket.h>。
参数
| 参数 | 类型 | 含义 | 常用取值或约束 |
|---|---|---|---|
domain |
int |
地址族,决定地址结构和协议族 | IPv4 常用 AF_INET,IPv6 常用 AF_INET6 |
type |
int |
通信语义 | TCP 场景常用 SOCK_STREAM,UDP 场景常用 SOCK_DGRAM |
protocol |
int |
指定具体协议 | 通常传 0,由系统为给定地址族与类型选择默认协议 |
domain、type 与 protocol 必须是内核支持且能够组合使用的值;不是任意三个常量都能互相搭配。
返回与错误
成功时返回非负文件描述符。该描述符属于进程资源,使用结束后应调用 close();否则长期运行的进程可能逐渐耗尽可用文件描述符。
失败时返回 -1 并设置 errno。常见原因包括地址族或协议不受支持、参数组合无效,以及进程或系统已达到文件描述符限制。不要依赖固定的描述符数字,具体值由当前进程已打开的资源决定。
完整示例
下面创建一个 IPv4 字节流 Socket,并在成功后立即释放资源。
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
int main(void) {
// protocol=0 让系统选择与 AF_INET + SOCK_STREAM 匹配的默认协议。
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
perror("socket");
return EXIT_FAILURE;
}
printf("socket fd=%d\n", fd);
// Socket 文件描述符不再使用时必须关闭。
if (close(fd) == -1) {
perror("close");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}预期输出:创建成功时会得到一个非负文件描述符,实际数字随进程状态变化。
socket fd=<ID><ID> 是运行时文件描述符,例如可能为 3、4 或其他非负整数。若创建失败,程序会由 perror() 输出与当前 errno 对应的错误信息并返回失败状态。
边界与兼容性
socket() 只创建通信端点,不会自动绑定本地端口,也不会建立远端连接。服务端通常继续调用 bind()、listen() 和 accept();主动连接的一端通常继续调用 connect()。
该签名属于 POSIX Socket API。具体可用的地址族、Socket 类型、协议以及扩展标志取决于操作系统;编写可移植代码时,不要把某个平台专有常量当作所有 POSIX 系统都支持的能力。
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);把 Socket 绑定到本地 IP 与端口;服务端通常在 listen 前调用,端口已占用、地址不匹配或权限不足时可能失败。
绑定本地地址
服务端需要明确在哪个本地地址和端口接收连接或数据时调用 bind()。绑定成功后,Socket 与指定本地地址关联;失败时返回 -1,应根据 errno 判断是端口冲突、地址无效、权限问题还是 Socket 状态不允许绑定。
签名
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);头文件为 <sys/socket.h>。IPv4 地址通常通过 struct sockaddr_in 构造,再转换为 const struct sockaddr * 传入。
参数
| 参数 | 类型 | 含义 | 约束 |
|---|---|---|---|
sockfd |
int |
已创建的 Socket 文件描述符 | 通常来自成功的 socket() 调用 |
addr |
const struct sockaddr * |
指向本地地址结构 | 地址结构必须与 Socket 的地址族匹配 |
addrlen |
socklen_t |
addr 指向结构的字节长度 |
IPv4 常传 sizeof(struct sockaddr_in) |
端口号和 IPv4 地址结构中的多字节字段使用网络字节序。端口通常通过 htons() 转换;文本 IPv4 地址可使用 inet_pton() 写入 sin_addr。
返回与错误
成功返回 0,失败返回 -1 并设置 errno。常见失败包括本地地址或端口已被占用、地址并不属于可绑定的本机接口、描述符不是 Socket,以及当前 Socket 已处于不允许再次绑定的状态。
某些低编号端口或受系统策略控制的地址可能需要额外权限,具体规则属于操作系统配置范围,不能仅根据 POSIX 签名判断。
完整示例
下面把 IPv4 TCP Socket 绑定到回环地址 127.0.0.1,端口指定为 0,让内核选择当前可用端口;随后用 getsockname() 读取实际绑定结果进行验证。
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
int main(void) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
perror("socket");
return EXIT_FAILURE;
}
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_port = htons(0); // 端口 0 表示由内核选择可用端口。
if (inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) != 1) {
fprintf(stderr, "invalid IPv4 address\n");
close(fd);
return EXIT_FAILURE;
}
if (bind(fd, (const struct sockaddr *)&addr, sizeof(addr)) == -1) {
perror("bind");
close(fd);
return EXIT_FAILURE;
}
// 读取内核最终分配的地址和端口,验证 bind() 的实际结果。
socklen_t addrlen = sizeof(addr);
if (getsockname(fd, (struct sockaddr *)&addr, &addrlen) == -1) {
perror("getsockname");
close(fd);
return EXIT_FAILURE;
}
char ip[INET_ADDRSTRLEN];
if (inet_ntop(AF_INET, &addr.sin_addr, ip, sizeof(ip)) == NULL) {
perror("inet_ntop");
close(fd);
return EXIT_FAILURE;
}
printf("bound to %s:%u\n", ip, (unsigned)ntohs(addr.sin_port));
close(fd);
return EXIT_SUCCESS;
}预期输出:地址保持为回环地址,端口由内核动态分配,因此实际值每次运行可能不同。
bound to 127.0.0.1:<PORT><PORT> 是运行时获得的非零端口号。若 bind() 失败,程序会由 perror() 输出当前系统提供的错误信息,并结束执行。
边界与兼容性
绑定 127.0.0.1 只允许通过本机回环接口访问;若服务需要监听所有 IPv4 本地接口,通常会使用通配地址,但这会扩大可达范围,应同时检查防火墙和应用访问控制。
bind() 本身不会让 TCP Socket 开始接受连接。TCP 服务端绑定成功后通常还需要调用 listen();同时,绑定成功只说明内核接受了该本地地址,不代表外部客户端一定能够通过网络、防火墙或路由访问它。
int listen(int sockfd, int backlog);将面向连接的 Socket 转为监听 Socket,并设置内核连接队列参数;只适用于支持连接语义的 Socket,常接在 bind 之后。
进入监听状态
在 TCP 服务端完成 socket() 和 bind() 后调用 listen(),把已绑定的面向连接 Socket 切换为被动监听状态,使内核开始维护等待 accept() 取出的连接队列。backlog 控制排队上限或提示值,不等于服务端可同时保持的已连接客户端总数。
签名与参数
int listen(int sockfd, int backlog);| 参数 | 类型 | 必填 | 默认值或约束 | 含义 |
|---|---|---|---|---|
sockfd |
int |
是 | 无默认值 | 面向连接的 Socket 描述符;服务器通常已先执行 bind() |
backlog |
int |
是 | 无默认值;实际有效上限由操作系统决定 | 控制等待应用接受的连接队列容量或提示值 |
返回与错误
成功返回 0。失败返回 -1 并设置 errno,常见原因包括描述符无效、参数不是 Socket,或底层协议不支持监听。
listen() 成功后,原来的 sockfd 仍是监听描述符;它不用于承载某个客户端的数据读写,后续应通过 accept() 获得新的已连接描述符。
完整示例
下面程序从命令行读取端口,绑定到回环地址后进入监听状态。实际运行时把 <PORT> 替换为未占用端口。
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
int main(int argc, char **argv) {
if (argc != 2) {
fprintf(stderr, "usage: %s <PORT>\n", argv[0]);
return 2;
}
char *end = NULL;
long value = strtol(argv[1], &end, 10);
if (*argv[1] == '\0' || *end != '\0' || value < 1 || value > 65535) {
fprintf(stderr, "invalid port\n");
return 2;
}
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
perror("socket");
return 1;
}
int reuse = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1) {
perror("setsockopt");
close(fd);
return 1;
}
struct sockaddr_in addr = {
.sin_family = AF_INET,
.sin_port = htons((unsigned short)value),
.sin_addr.s_addr = htonl(INADDR_LOOPBACK)
};
if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
perror("bind");
close(fd);
return 1;
}
if (listen(fd, 16) == -1) {
perror("listen");
close(fd);
return 1;
}
printf("listening on 127.0.0.1:%ld\n", value);
close(fd);
return 0;
}预期输出:
listening on 127.0.0.1:<PORT>边界与兼容性
backlog 是等待被应用接受的连接队列参数,不是线程数、最大在线连接数或文件描述符上限。不同系统会对该值做截断或采用不同队列语义;需要容量调优时应结合目标系统文档和内核配置验证。对 UDP 等无连接 Socket 调用 listen() 不适用。
int accept(int sockfd, struct sockaddr *restrict addr, socklen_t *restrict addrlen);从监听 Socket 的已完成连接队列取出一个客户端连接,并返回新的已连接 Socket;监听描述符继续负责接受后续连接。
接受客户端连接
监听 Socket 已进入 listen() 状态后调用 accept(),从已完成连接队列取出一个连接,并返回新的已连接 Socket。监听描述符继续保留,用来接受后续客户端;数据收发应使用 accept() 返回的新描述符。
签名与参数
int accept(int sockfd, struct sockaddr *restrict addr, socklen_t *restrict addrlen);| 参数 | 类型 | 必填 | 默认值或约束 | 含义 |
|---|---|---|---|---|
sockfd |
int |
是 | 无默认值 | 处于监听状态的 Socket 描述符 |
addr |
struct sockaddr * |
否 | 可为 NULL |
接收客户端地址的缓冲区 |
addrlen |
socklen_t * |
条件必填 | addr 非 NULL 时提供 |
调用前写入缓冲区大小,返回后更新为实际地址长度 |
若地址缓冲区小于实际地址长度,返回的地址内容可能被截断;应根据返回后的 addrlen 判断实际所需长度。
返回与错误
成功返回新的已连接 Socket 描述符,值不小于 0;失败返回 -1 并设置 errno。
阻塞监听 Socket 在没有已完成连接时通常会等待。若监听 Socket 为非阻塞模式且当前没有可接受连接,常见结果是 -1,并将 errno 设为 EAGAIN 或 EWOULDBLOCK;被信号中断时可能得到 EINTR。
accept() 返回的新描述符与监听描述符生命周期独立。关闭某个客户端连接时只关闭对应的已连接描述符;停止继续接收新连接时才关闭监听描述符。
完整示例
下面程序在回环地址上创建监听 Socket,并 fork() 一个子进程主动连接,父进程随后调用 accept()。这样可以单独运行并验证返回的是新的客户端连接描述符。
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
int main(void) {
int listener = socket(AF_INET, SOCK_STREAM, 0);
if (listener == -1) {
perror("socket");
return 1;
}
struct sockaddr_in server = {
.sin_family = AF_INET,
.sin_port = htons(0),
.sin_addr.s_addr = htonl(INADDR_LOOPBACK)
};
if (bind(listener, (struct sockaddr *)&server, sizeof(server)) == -1) {
perror("bind");
close(listener);
return 1;
}
if (listen(listener, 8) == -1) {
perror("listen");
close(listener);
return 1;
}
socklen_t server_len = sizeof(server);
if (getsockname(listener, (struct sockaddr *)&server, &server_len) == -1) {
perror("getsockname");
close(listener);
return 1;
}
pid_t pid = fork();
if (pid == -1) {
perror("fork");
close(listener);
return 1;
}
if (pid == 0) {
int client = socket(AF_INET, SOCK_STREAM, 0);
if (client == -1) {
perror("socket");
_exit(1);
}
if (connect(client, (struct sockaddr *)&server, sizeof(server)) == -1) {
perror("connect");
close(client);
_exit(1);
}
close(client);
_exit(0);
}
struct sockaddr_in peer;
socklen_t peer_len = sizeof(peer);
int connected = accept(listener, (struct sockaddr *)&peer, &peer_len);
if (connected == -1) {
perror("accept");
close(listener);
waitpid(pid, NULL, 0);
return 1;
}
char ip[INET_ADDRSTRLEN];
if (inet_ntop(AF_INET, &peer.sin_addr, ip, sizeof(ip)) == NULL) {
perror("inet_ntop");
close(connected);
close(listener);
waitpid(pid, NULL, 0);
return 1;
}
printf("accepted client from %s\n", ip);
close(connected);
close(listener);
waitpid(pid, NULL, 0);
return 0;
}预期输出:
accepted client from 127.0.0.1边界与兼容性
accept() 一次只取出一个已建立连接;高并发服务器通常需要循环调用,并结合阻塞、非阻塞或事件通知模型处理 EINTR 与 EAGAIN。如果不关心对端地址,可同时传 addr = NULL 和 addrlen = NULL。Linux 还提供 accept4() 以便在创建连接描述符时原子设置部分标志,但它不是这里这个 POSIX accept() 签名的一部分。
int accept4(int sockfd, struct sockaddr *restrict addr, socklen_t *restrict addrlen, int flags);Linux 扩展的 accept,可在创建已连接 Socket 时一次设置 SOCK_NONBLOCK 或 SOCK_CLOEXEC,减少额外 fcntl 调用与并发竞态窗口。
原子接受并设置标志
需要从监听 Socket 取出连接,并在新描述符创建时立即设置非阻塞或 close-on-exec 标志时使用 accept4。这样可避免先 accept、再 fcntl 的额外系统调用,也缩短多线程程序中描述符标志尚未设置的竞态窗口。
签名与参数
int accept4(int sockfd, struct sockaddr *restrict addr,
socklen_t *restrict addrlen, int flags);| 参数 | 类型 | 含义与约束 |
|---|---|---|
sockfd |
int |
已执行 listen 的监听 Socket。 |
addr |
struct sockaddr * |
接收对端地址;不需要地址时可传 NULL。 |
addrlen |
socklen_t * |
addr 非空时,调用前给出缓冲区大小,成功后写回实际地址长度;addr 为 NULL 时通常一并传 NULL。 |
flags |
int |
0,或按位组合 SOCK_NONBLOCK、SOCK_CLOEXEC。 |
SOCK_NONBLOCK 让返回的已连接 Socket 带 O_NONBLOCK;SOCK_CLOEXEC 设置 FD_CLOEXEC。两者都在创建新描述符时完成,不需要后续 fcntl。
返回与错误
成功返回非负的新 Socket 文件描述符;失败返回 -1 并设置 errno。非阻塞监听 Socket 当前没有待处理连接时通常得到 EAGAIN 或 EWOULDBLOCK;信号中断可得到 EINTR,非法标志可得到 EINVAL,描述符耗尽时可能得到 EMFILE 或 ENFILE。
Linux 还可能把新连接上已挂起的网络错误直接作为 accept4 的错误返回。事件循环不要把一次可读通知等同于“下一次接受必定成功”,应按错误类型决定重试或记录故障。
完整示例
下面程序在回环地址创建监听 Socket,由子进程发起一次连接,父进程用 accept4 接受并检查两个标志,因此不依赖外部服务。
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
static void die(const char *msg) {
perror(msg);
exit(EXIT_FAILURE);
}
int main(void) {
int lfd = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
if (lfd < 0) die("socket");
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr.sin_port = 0;
if (bind(lfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) die("bind");
if (listen(lfd, 1) < 0) die("listen");
socklen_t addrlen = sizeof(addr);
if (getsockname(lfd, (struct sockaddr *)&addr, &addrlen) < 0) die("getsockname");
pid_t pid = fork();
if (pid < 0) die("fork");
if (pid == 0) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) _exit(2);
if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) _exit(3);
close(fd);
_exit(0);
}
int fd = accept4(lfd, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (fd < 0) die("accept4");
int status_flags = fcntl(fd, F_GETFL);
int descriptor_flags = fcntl(fd, F_GETFD);
if (status_flags < 0 || descriptor_flags < 0) die("fcntl");
printf("nonblock=%d cloexec=%d\n",
!!(status_flags & O_NONBLOCK),
!!(descriptor_flags & FD_CLOEXEC));
close(fd);
close(lfd);
int child_status = 0;
if (waitpid(pid, &child_status, 0) < 0) die("waitpid");
return WIFEXITED(child_status) && WEXITSTATUS(child_status) == 0
? EXIT_SUCCESS : EXIT_FAILURE;
}预期输出:
nonblock=1 cloexec=1边界与兼容性
在 glibc 上使用该原型通常需要在包含头文件前定义 _GNU_SOURCE。accept4 自 Linux 2.6.28、glibc 2.10 起可用;POSIX.1-2024 已纳入该接口,但面向旧系统或非 Linux 平台时仍应检查实现是否提供它。若只使用 accept,不要假定 Linux 会把监听 Socket 的 O_NONBLOCK 自动继承给新连接。
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);让客户端 Socket 主动连接指定服务端地址;阻塞模式通常等待连接完成,非阻塞模式可能返回 EINPROGRESS,需要后续检查连接结果。
主动连接服务端
客户端已有 Socket,需要向指定地址发起连接时调用 connect。阻塞 Socket 通常等待连接完成后返回;非阻塞 Socket 常以 EINPROGRESS 表示连接正在后台建立,此时应等待可写事件,再读取 SO_ERROR 判断最终结果。
签名与参数
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);| 参数 | 类型 | 含义与约束 |
|---|---|---|
sockfd |
int |
尚未完成目标连接的 Socket 文件描述符。 |
addr |
const struct sockaddr * |
目标地址;实际结构由地址族决定,例如 IPv4 使用 struct sockaddr_in。 |
addrlen |
socklen_t |
addr 指向的地址结构长度,必须与所用地址族匹配。 |
TCP 客户端通常先用 socket 创建流式 Socket,再填充目标 IP 和端口后调用 connect。
返回与错误
连接立即成功时返回 0;失败返回 -1 并设置 errno。对非阻塞 Internet Socket,EINPROGRESS 表示连接尚未完成而不是最终失败;后续 poll、select 或同类机制报告可写后,必须通过 getsockopt(fd, SOL_SOCKET, SO_ERROR, ...) 读取最终错误码,不能仅凭“可写”判断成功。
常见失败包括 ECONNREFUSED、ETIMEDOUT、ENETUNREACH、EADDRNOTAVAIL;已有连接可得到 EISCONN,同一非阻塞连接仍在进行时可能得到 EALREADY。UNIX 域非阻塞 Socket 在不能立即完成时可能使用 EAGAIN,不能把所有地址族都按 EINPROGRESS 处理。
完整示例
下面是完整的 IPv4 非阻塞客户端。运行前确保 127.0.0.1 的目标端口已有 TCP 服务监听,并把实际端口数字作为程序的第一个参数。
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
static void fail(const char *msg, int fd) {
perror(msg);
if (fd >= 0) close(fd);
exit(EXIT_FAILURE);
}
int main(int argc, char **argv) {
if (argc != 2) {
fprintf(stderr, "usage: %s <PORT>\n", argv[0]);
return 2;
}
char *end = NULL;
long port = strtol(argv[1], &end, 10);
if (*argv[1] == '\0' || *end != '\0' || port < 1 || port > 65535) {
fprintf(stderr, "invalid port\n");
return 2;
}
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) fail("socket", -1);
int flags = fcntl(fd, F_GETFL);
if (flags < 0 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
fail("fcntl", fd);
}
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_port = htons((uint16_t)port);
if (inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) != 1) {
fail("inet_pton", fd);
}
int rc = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
if (rc < 0 && errno != EINPROGRESS) {
fail("connect", fd);
}
if (rc < 0) {
struct pollfd pfd = {.fd = fd, .events = POLLOUT};
int poll_rc;
do {
poll_rc = poll(&pfd, 1, 5000);
} while (poll_rc < 0 && errno == EINTR);
if (poll_rc == 0) {
fprintf(stderr, "connect timeout\n");
close(fd);
return 1;
}
if (poll_rc < 0) fail("poll", fd);
int so_error = 0;
socklen_t len = sizeof(so_error);
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &so_error, &len) < 0) {
fail("getsockopt", fd);
}
if (so_error != 0) {
errno = so_error;
fail("connect", fd);
}
}
puts("connected");
close(fd);
return 0;
}预期输出:目标端口可连接时为:
connected若目标未监听或路由不可达,程序进入错误分支;具体 perror 文本受系统和本地化设置影响。示例中的 5000 是 5 秒应用层等待上限,不代表内核 TCP 的默认连接超时。
边界与兼容性
可写事件既可能表示连接成功,也可能表示连接失败,因此 SO_ERROR 检查不可省略。若一次 connect 最终失败,为获得可移植行为,通常关闭该 Socket 并重新创建后再重试,而不是假定原描述符仍处于可复用状态。示例保持 Socket 为非阻塞模式;若后续代码需要阻塞 I/O,应显式恢复原来的文件状态标志。
int close(int fd);关闭文件描述符并释放对应资源;对 Socket 的 close 会影响引用计数和连接生命周期,多线程或 dup 场景下要注意其他引用仍可能存在。
关闭 Socket 文件描述符
当某个 Socket 文件描述符不再使用时调用 close。它释放当前文件描述符这一份引用;只有关联同一打开文件描述的最后一个引用被关闭后,内核才会进入最终的 Socket 关闭处理,因此 dup、fork 和多线程共享描述符时要特别确认引用关系。
签名
#include <unistd.h>
int close(int fd);| 参数 | 类型 | 必填 | 含义 |
|---|---|---|---|
fd |
int |
是 | 要关闭的有效文件描述符;Socket 描述符同样使用此接口 |
close 没有默认参数。成功返回 0;失败返回 -1 并设置 errno。EBADF 表示传入的描述符无效。其他错误以及收到信号后的处理细节存在平台差异,不应在未确认目标系统语义时盲目重复调用 close(fd),因为描述符编号可能已经被其他线程重新利用。
引用与连接生命周期
close 操作的是文件描述符引用,而不是简单地向对端发送“连接关闭”命令。通过 dup 等方式得到的描述符仍引用同一个 Socket 时,关闭其中一个描述符不会使其他引用立即失效。
这与 shutdown 不同:shutdown 改变 Socket 的收发能力,而 close 释放调用方持有的描述符。即使已经调用 shutdown,最终通常仍需要 close 回收描述符。
完整示例
下面使用本地流式 socketpair 验证 dup 后关闭原描述符不会销毁仍被引用的 Socket。保存为 close_demo.c 后,可用 cc close_demo.c -o close_demo && ./close_demo 编译运行。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
int main(void) {
int sv[2];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
perror("socketpair");
return 1;
}
int duplicate = dup(sv[0]);
if (duplicate == -1) {
perror("dup");
return 1;
}
// 只关闭原描述符;duplicate 仍引用同一个 Socket。
if (close(sv[0]) == -1) {
perror("close");
return 1;
}
if (write(duplicate, "ping", 4) != 4) {
perror("write");
return 1;
}
char buf[5] = {0};
if (read(sv[1], buf, 4) != 4) {
perror("read");
return 1;
}
printf("received: %s\n", buf);
close(duplicate);
close(sv[1]);
return 0;
}预期输出:
received: ping该结果说明关闭 sv[0] 后,复制得到的描述符仍可通信;只有相应引用都被释放后,Socket 才不再由这些描述符持有。
边界与常见误用
不要在一个线程关闭描述符后,假定另一个线程仍能安全地继续使用同一个整数值;描述符编号可能很快被复用。若协议需要明确表达“请求已经发送完,但还要读取响应”,优先使用 shutdown(sockfd, SHUT_WR),而不是提前用 close 丢失读取能力。
int shutdown(int sockfd, int how);单独关闭读端、写端或双向通信,比 close 更适合表达 TCP 半关闭语义;SHUT_WR 常用于发送完请求后继续读取服务端响应。
半关闭 Socket
当发送方向已经结束、但仍需继续接收对端数据时调用 shutdown。TCP 中最常见的是 shutdown(sockfd, SHUT_WR):停止本端后续发送,同时保留读取能力,让对端通过 EOF 感知本端发送方向已经结束。
签名
#include <sys/socket.h>
int shutdown(int sockfd, int how);| 参数 | 类型 | 必填 | 含义 |
|---|---|---|---|
sockfd |
int |
是 | 已创建的 Socket 文件描述符 |
how |
int |
是 | SHUT_RD、SHUT_WR 或 SHUT_RDWR,决定关闭哪个通信方向 |
SHUT_RD 禁止后续接收,SHUT_WR 禁止后续发送,SHUT_RDWR 同时关闭两个方向。shutdown 没有默认参数。
返回与错误
成功返回 0;失败返回 -1 并设置 errno。常见失败包括描述符不是 Socket、描述符无效,或给出了目标系统不支持的 how 值。对连接型 Socket 调用时,还应确认连接已经处于适合关闭通信方向的状态。
对 TCP 使用 SHUT_WR 时,已经排队等待发送的数据仍按协议处理,随后本端发送方向结束;对端通常在读完已有数据后通过 recv 返回 0 感知 EOF。本端仍可继续 recv 对端随后发送的数据。
半关闭与 close 的区别

shutdown 改变的是 Socket 的通信方向,不负责释放文件描述符;调用后仍应在不再使用时执行 close(sockfd)。对于由 dup 等方式复制出的、指向同一 Socket 的描述符,shutdown 对共享的 Socket 通信状态产生影响,而单独 close 一个描述符只释放那一份描述符引用。
完整示例
下面在回环地址上建立真实 TCP 连接。客户端发送 ping 后执行 SHUT_WR,服务端读到 EOF 后仍发送 pong,客户端继续读取响应。保存为 shutdown_demo.c 后,可用 cc shutdown_demo.c -o shutdown_demo && ./shutdown_demo 编译运行。
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
int main(void) {
int listener = socket(AF_INET, SOCK_STREAM, 0);
if (listener == -1) {
perror("socket");
return 1;
}
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr.sin_port = htons(0);
if (bind(listener, (struct sockaddr *)&addr, sizeof(addr)) == -1 ||
listen(listener, 1) == -1) {
perror("bind/listen");
return 1;
}
socklen_t len = sizeof(addr);
if (getsockname(listener, (struct sockaddr *)&addr, &len) == -1) {
perror("getsockname");
return 1;
}
int client = socket(AF_INET, SOCK_STREAM, 0);
if (client == -1 ||
connect(client, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
perror("connect");
return 1;
}
int server = accept(listener, NULL, NULL);
if (server == -1) {
perror("accept");
return 1;
}
if (send(client, "ping", 4, 0) != 4 ||
shutdown(client, SHUT_WR) == -1) {
perror("send/shutdown");
return 1;
}
char request[5] = {0};
if (recv(server, request, 4, MSG_WAITALL) != 4) {
perror("recv request");
return 1;
}
char eof_probe;
if (recv(server, &eof_probe, 1, 0) != 0) {
fprintf(stderr, "expected EOF\n");
return 1;
}
if (send(server, "pong", 4, 0) != 4) {
perror("send response");
return 1;
}
char response[5] = {0};
if (recv(client, response, 4, MSG_WAITALL) != 4) {
perror("recv response");
return 1;
}
printf("server received: %s\n", request);
printf("client received: %s\n", response);
close(server);
close(client);
close(listener);
return 0;
}预期输出:
server received: ping
client received: pong服务端能够先观察到客户端发送方向的 EOF,再继续向客户端发送 pong,说明 SHUT_WR 并未关闭客户端的读取方向。
边界与常见误用
调用 SHUT_WR 后不要再把该 Socket 当作可发送连接继续写入;若应用需要再次发送数据,应重新设计协议状态或建立新连接。shutdown 也不是资源释放接口,完成双方通信后仍需执行 close。
int getsockname(int sockfd, struct sockaddr *restrict addr, socklen_t *restrict addrlen);读取 Socket 当前绑定的本地地址;客户端使用端口 0 让内核自动分配临时端口后,可用它获取最终选择的本地端点。
查询本地地址
当 Socket 已绑定或已由内核隐式选择本地端点时,用 getsockname 读取当前本地地址和端口。典型场景是 bind 时把端口设为 0,随后取得内核实际分配的临时端口。
签名
int getsockname(int sockfd, struct sockaddr *restrict addr, socklen_t *restrict addrlen);参数
| 参数 | 类型 | 必填 | 含义与约束 |
|---|---|---|---|
sockfd |
int |
是 | 已创建的 Socket 文件描述符。 |
addr |
struct sockaddr * |
是 | 接收本地地址;实际应传入与地址族匹配的结构,如 IPv4 的 struct sockaddr_in。 |
addrlen |
socklen_t * |
是 | 输入时给出 addr 缓冲区大小,返回时改写为实际地址长度。 |
addr 与 addrlen 都是输出相关参数;调用前必须把 *addrlen 初始化为接收结构的大小。
返回与错误
成功返回 0,并写入本地地址及实际长度;失败返回 -1 并设置 errno。常见失败包括无效文件描述符、描述符并非 Socket,或地址缓冲区参数无效。
对 AF_INET/AF_INET6 Socket,端口字段仍是网络字节序,读取时应使用 ntohs;地址文本化可用 inet_ntop。
完整示例
下面创建 IPv4 TCP Socket,绑定到回环地址并让内核自动分配端口,再用 getsockname 读取最终端点。
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
int main(void) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
perror("socket");
return 1;
}
struct sockaddr_in local = {0};
local.sin_family = AF_INET;
local.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
local.sin_port = htons(0); // 让内核选择空闲临时端口
if (bind(fd, (struct sockaddr *)&local, sizeof(local)) == -1) {
perror("bind");
close(fd);
return 1;
}
socklen_t len = sizeof(local);
if (getsockname(fd, (struct sockaddr *)&local, &len) == -1) {
perror("getsockname");
close(fd);
return 1;
}
char ip[INET_ADDRSTRLEN];
if (inet_ntop(AF_INET, &local.sin_addr, ip, sizeof(ip)) == NULL) {
perror("inet_ntop");
close(fd);
return 1;
}
printf("local=%s:%u\n", ip, (unsigned)ntohs(local.sin_port));
close(fd);
return 0;
}预期输出:
local=127.0.0.1:<PORT><PORT> 是内核本次分配的端口,实际值每次运行可能不同。
边界与兼容性
getsockname 返回的是当前 Socket 的本地端点,不代表主机“所有可用地址”。客户端在显式 bind 前,如果尚未触发隐式绑定,返回内容可能不能代表最终连接使用的端点;通常在 connect 成功后再查询最明确。
int getpeername(int sockfd, struct sockaddr *restrict addr, socklen_t *restrict addrlen);读取已连接 Socket 的远端地址;常用于记录客户端 IP 与端口,但仅适用于已经建立对端关系的 Socket。
查询对端地址
当 Socket 已建立对端关系时,用 getpeername 读取远端地址和端口。它适合在连接建立后补取对端信息,例如日志记录、访问审计或在没有保留 accept 返回地址时重新查询。
签名
int getpeername(int sockfd, struct sockaddr *restrict addr, socklen_t *restrict addrlen);参数
| 参数 | 类型 | 必填 | 含义与约束 |
|---|---|---|---|
sockfd |
int |
是 | 已连接 Socket 的文件描述符。 |
addr |
struct sockaddr * |
是 | 接收对端地址;应按实际地址族提供匹配结构,如 struct sockaddr_in。 |
addrlen |
socklen_t * |
是 | 输入时是缓冲区大小,返回时改写为实际地址长度。 |
调用前必须先初始化 *addrlen。对于 IPv4/IPv6,返回的端口仍是网络字节序,需要用 ntohs 转换。
返回与错误
成功返回 0 并写入对端地址;失败返回 -1 并设置 errno。若 Socket 尚未连接到对端,典型结果是失败并报告未连接状态;无效描述符或非 Socket 描述符也会失败。
getpeername 读取的是该 Socket 当前内核记录的对端。服务端 accept 创建的已连接 Socket 可以调用它,监听 Socket 本身不能用它取得某个客户端地址。
完整示例
下面在本机创建 TCP 监听端,子进程连接它,父进程对 accept 得到的已连接 Socket 调用 getpeername。
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
int main(void) {
int listener = socket(AF_INET, SOCK_STREAM, 0);
if (listener == -1) {
perror("socket");
return 1;
}
struct sockaddr_in server = {0};
server.sin_family = AF_INET;
server.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
server.sin_port = htons(0);
if (bind(listener, (struct sockaddr *)&server, sizeof(server)) == -1 ||
listen(listener, 1) == -1) {
perror("bind/listen");
close(listener);
return 1;
}
socklen_t server_len = sizeof(server);
if (getsockname(listener, (struct sockaddr *)&server, &server_len) == -1) {
perror("getsockname");
close(listener);
return 1;
}
pid_t pid = fork();
if (pid == -1) {
perror("fork");
close(listener);
return 1;
}
if (pid == 0) {
int client = socket(AF_INET, SOCK_STREAM, 0);
if (client == -1 ||
connect(client, (struct sockaddr *)&server, sizeof(server)) == -1) {
perror("client");
_exit(1);
}
close(client);
_exit(0);
}
int conn = accept(listener, NULL, NULL);
if (conn == -1) {
perror("accept");
close(listener);
return 1;
}
struct sockaddr_in peer = {0};
socklen_t peer_len = sizeof(peer);
if (getpeername(conn, (struct sockaddr *)&peer, &peer_len) == -1) {
perror("getpeername");
close(conn);
close(listener);
return 1;
}
char ip[INET_ADDRSTRLEN];
if (inet_ntop(AF_INET, &peer.sin_addr, ip, sizeof(ip)) == NULL) {
perror("inet_ntop");
close(conn);
close(listener);
return 1;
}
printf("peer=%s:%u\n", ip, (unsigned)ntohs(peer.sin_port));
close(conn);
close(listener);
waitpid(pid, NULL, 0);
return 0;
}预期输出:
peer=127.0.0.1:<PORT><PORT> 是子进程 TCP 客户端的临时本地端口,实际值可能不同。
边界与兼容性
getpeername 不能替代连接状态判断:对未连接的流式 Socket 调用会失败。对经过代理或应用层网关的连接,它只能报告传输层实际对端,并不会自动还原代理之前的原始客户端地址。
Socket 选项与参数
int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);修改内核维护的 Socket 选项,例如 SO_REUSEADDR、SO_KEEPALIVE 和 TCP_NODELAY;具体选项必须匹配对应 level 与数据类型。
设置 Socket 选项
需要在已有 Socket 上启用、关闭或调整协议选项时调用 setsockopt。关键是让 level、optname、optval 的数据类型和 optlen 保持匹配;调用成功只表示内核接受了这次设置,必要时应再用 getsockopt 验证实际值。
签名
int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);| 参数 | 类型 | 含义 | 约束 |
|---|---|---|---|
sockfd |
int |
已创建的 Socket 文件描述符 | 必须仍然有效 |
level |
int |
选项所属协议层 | 常见为 SOL_SOCKET、IPPROTO_TCP |
optname |
int |
要修改的选项 | 必须属于指定 level |
optval |
const void * |
指向选项值的缓冲区 | 实际类型由具体选项定义 |
optlen |
socklen_t |
optval 指向数据的长度 |
通常使用对应对象的 sizeof |
例如 SO_REUSEADDR、SO_KEEPALIVE 属于 SOL_SOCKET;TCP_NODELAY 属于 TCP 协议层,不能只按选项名字猜测 level 或数据类型。
返回与错误
成功返回 0;失败返回 -1,并设置 errno。失败时应保留并检查系统错误,而不是继续假定选项已经生效。
常见失败原因包括描述符无效、指定选项不受支持、参数长度与选项期望不匹配,或者当前 Socket 状态不允许修改该选项。具体可用选项及其取值语义还受操作系统和协议实现影响。
完整示例
下面创建 TCP Socket,启用 SO_REUSEADDR,随后读取该选项验证设置结果。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
int main(void) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
perror("socket");
return EXIT_FAILURE;
}
int enabled = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
&enabled, sizeof(enabled)) == -1) {
perror("setsockopt");
close(fd);
return EXIT_FAILURE;
}
int current = 0;
socklen_t len = sizeof(current);
if (getsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
¤t, &len) == -1) {
perror("getsockopt");
close(fd);
return EXIT_FAILURE;
}
printf("SO_REUSEADDR enabled: %s\n", current ? "yes" : "no");
close(fd);
return EXIT_SUCCESS;
}预期输出:
SO_REUSEADDR enabled: yes边界与兼容性
不要把所有选项都按 int 传入。虽然许多布尔型 Socket 选项使用整数,但缓冲区大小、超时、组播及协议专用选项可能要求其他结构体或类型,应以目标系统对应选项的接口定义为准。
setsockopt 也不能替代调用时机要求。某些选项需要在 bind、connect 或 listen 前设置才能影响预期行为;具体顺序取决于选项和平台。跨平台代码应避免假设同名选项在所有系统上具有完全一致的语义。
int getsockopt(int sockfd, int level, int optname, void *restrict optval, socklen_t *restrict optlen);读取当前 Socket 选项值并返回实际长度;排查缓冲区、保活、复用等行为时,可用它验证设置是否真正作用到目标描述符。
读取 Socket 选项
需要确认某个 Socket 当前实际采用的选项值时调用 getsockopt,尤其适合验证 setsockopt 是否作用到了正确描述符。调用前必须同时准备结果缓冲区和它的容量,返回后再读取更新后的 optlen。
签名
int getsockopt(int sockfd, int level, int optname, void *restrict optval, socklen_t *restrict optlen);| 参数 | 类型 | 含义 | 约束 |
|---|---|---|---|
sockfd |
int |
要查询的 Socket 文件描述符 | 必须仍然有效 |
level |
int |
选项所属协议层 | 必须与 optname 对应 |
optname |
int |
要读取的选项 | 可用范围取决于协议和平台 |
optval |
void * |
接收选项值的缓冲区 | 调用方负责提供足够空间 |
optlen |
socklen_t * |
输入缓冲区容量,并接收实际长度 | 调用前必须初始化 |
optlen 是输入输出参数:进入函数时表示 optval 可容纳的字节数,成功返回后表示结果实际使用的长度。因此不能传入未初始化的 socklen_t。
返回与错误
成功返回 0,并把结果写入 optval,同时更新 *optlen;失败返回 -1 并设置 errno。失败后不要使用缓冲区中的旧值判断当前 Socket 状态。
如果查询的 level 与 optname 不匹配、描述符不是有效 Socket,或者目标系统不支持该选项,调用可能失败。返回值的数据类型也由具体选项定义,不能统一按整数解释。
完整示例
下面创建一个 TCP 流式 Socket,再通过 SO_TYPE 读取其类型。示例比较符号常量而不是打印常量的数值,避免依赖平台上的具体整数编码。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
int main(void) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
perror("socket");
return EXIT_FAILURE;
}
int type = 0;
socklen_t len = sizeof(type);
if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &len) == -1) {
perror("getsockopt");
close(fd);
return EXIT_FAILURE;
}
printf("SO_TYPE is SOCK_STREAM: %s\n",
type == SOCK_STREAM ? "yes" : "no");
printf("returned length matches int: %s\n",
len == sizeof(type) ? "yes" : "no");
close(fd);
return EXIT_SUCCESS;
}预期输出:
SO_TYPE is SOCK_STREAM: yes
returned length matches int: yes排查读取结果
读取缓冲区大小、保活或复用选项时,应查询发生问题的那个实际描述符。服务端监听 Socket 与 accept 返回的已连接 Socket 是不同描述符,不能因为它们属于同一服务就默认所有选项值完全相同。
如果刚调用过 setsockopt,可立即使用相同的 level 和 optname 查询并比较结果。对于由内核调整、规范化或采用结构体返回的选项,应以 getsockopt 得到的实际值和实际长度为准。
边界与兼容性
不同选项可能返回 int、结构体或其他协议定义的数据,声明接收变量前应先确认该选项的接口类型。跨平台代码还应确认选项本身是否存在,以及同名选项的数据布局和语义是否一致;不能仅凭 getsockopt 的统一函数签名推断结果格式。
int fcntl(int fd, int cmd, ...);通过 F_GETFL 与 F_SETFL 配置 O_NONBLOCK;这是传统 Socket 非阻塞控制方式,修改时应保留原有文件状态标志,避免意外覆盖。
切换非阻塞模式
需要让 Socket 的 read、recv、accept 等操作在暂时无数据时立即返回,而不是阻塞线程时,可用 fcntl 读取现有文件状态标志,再加入 O_NONBLOCK。关键是保留原有标志,不能直接用 F_SETFL 覆盖成单独的 O_NONBLOCK。
签名
int fcntl(int fd, int cmd, ...);本条目的典型调用分两步:F_GETFL 读取当前状态标志,F_SETFL 写回加入或移除 O_NONBLOCK 后的标志。
| 参数 | 类型 | 含义 | 约束 |
|---|---|---|---|
fd |
int |
要修改的文件描述符 | 必须是有效且支持相关操作的描述符 |
cmd |
int |
fcntl 操作类型 |
此处使用 F_GETFL 或 F_SETFL |
| 第三个参数 | 可变参数 | F_SETFL 时传新的状态标志 |
F_GETFL 不需要该参数 |
返回与错误
F_GETFL 成功时返回当前文件状态标志;F_SETFL 成功时返回 0。调用失败均返回 -1 并设置 errno,常见原因包括描述符无效或操作参数不合法。
设置非阻塞模式时应先取得原值,再执行 flags | O_NONBLOCK;恢复阻塞模式则使用 flags & ~O_NONBLOCK。这样可以避免覆盖描述符已有的其他可修改状态标志。
完整示例
下面创建一对本地 Socket,将其中一个端点切换为非阻塞,并再次读取标志验证结果。
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
int main(void) {
int sv[2];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
perror("socketpair");
return EXIT_FAILURE;
}
int flags = fcntl(sv[0], F_GETFL);
if (flags == -1) {
perror("fcntl F_GETFL");
return EXIT_FAILURE;
}
/* 保留已有状态标志,只增加非阻塞属性。 */
if (fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == -1) {
perror("fcntl F_SETFL");
return EXIT_FAILURE;
}
int updated = fcntl(sv[0], F_GETFL);
if (updated == -1) {
perror("fcntl F_GETFL");
return EXIT_FAILURE;
}
printf("O_NONBLOCK %s\\n", (updated & O_NONBLOCK) ? "enabled" : "disabled");
close(sv[0]);
close(sv[1]);
return EXIT_SUCCESS;
}预期输出:
O_NONBLOCK enabled边界与常见误用
O_NONBLOCK 改变的是相关打开文件描述所关联的状态标志,因此通过 dup 等方式得到并共享同一打开文件描述的描述符可能同时受到影响。对 Socket 而言,非阻塞调用暂时无法完成时通常返回 -1,并通过 errno 报告 EAGAIN 或 EWOULDBLOCK;应用应进入事件等待或稍后重试,而不是把它当成连接故障。
int socketpair(int domain, int type, int protocol, int sv[2]);创建一对相互连接的本地 Socket,常用于父子进程或线程之间双向传输;典型场景为 AF_UNIX 配合 SOCK_STREAM 或 SOCK_DGRAM。
创建本地 Socket 对
需要在同一主机内立即获得两个已经互相连接、可双向读写的 Socket 端点时,可调用 socketpair。它省去了 bind、listen、connect 和 accept 的建连流程,常用于 fork 前建立父子进程通信通道或进程内部测试 Socket 读写逻辑。
签名
int socketpair(int domain, int type, int protocol, int sv[2]);| 参数 | 类型 | 含义 | 常用值或约束 |
|---|---|---|---|
domain |
int |
通信域 | POSIX 本地通信通常使用 AF_UNIX |
type |
int |
Socket 类型 | 常用 SOCK_STREAM 或 SOCK_DGRAM |
protocol |
int |
协议选择 | 对常见 UNIX 域 Socket 通常传 0 |
sv |
int[2] |
接收两个端点描述符 | 成功后 sv[0] 与 sv[1] 已互相连接 |
返回与错误
成功时返回 0,并把两个新文件描述符写入 sv[0] 和 sv[1];失败时返回 -1 并设置 errno。失败可能来自不支持的 domain/type 组合、进程或系统文件描述符耗尽,以及资源不足等情况。
对于 SOCK_STREAM,两个端点提供可靠的双向字节流,但不会保留每次 write 的消息边界;读取方应根据协议自行处理长度或分隔方式。SOCK_DGRAM 则保留数据报边界。
完整示例
下面创建一个 AF_UNIX、SOCK_STREAM Socket 对,从 sv[0] 写入数据,并从 sv[1] 读取验证双向通道已经建立。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
int main(void) {
int sv[2];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
perror("socketpair");
return EXIT_FAILURE;
}
const char message[] = "ping";
if (write(sv[0], message, sizeof(message) - 1) == -1) {
perror("write");
return EXIT_FAILURE;
}
char buffer[16] = {0};
ssize_t n = read(sv[1], buffer, sizeof(buffer) - 1);
if (n == -1) {
perror("read");
return EXIT_FAILURE;
}
/* read 不自动追加字符串终止符,因此按实际长度补齐。 */
buffer[n] = '\\0';
printf("peer received: %s\\n", buffer);
close(sv[0]);
close(sv[1]);
return EXIT_SUCCESS;
}预期输出:
peer received: ping边界与兼容性
socketpair 用于同一主机内的端点,不负责建立 TCP/IP 网络连接。POSIX 场景应优先使用标准支持的 AF_UNIX 与相应 Socket 类型;某些系统还允许在 type 中组合创建时标志,但这类扩展并非所有 POSIX 平台都提供,要求可移植代码时应单独使用 fcntl 等标准接口设置描述符属性。
在 fork 场景中,父子进程会继承两个端点,通常应各自关闭不使用的一端,否则可能导致引用仍然存在,使依赖 EOF 判断对端关闭的逻辑迟迟不能结束。
数据收发
ssize_t send(int sockfd, const void *buf, size_t len, int flags);向已连接 Socket 发送数据;返回值表示本次实际写入的字节数,不保证一次覆盖全部缓冲区,非阻塞模式下还需处理 EAGAIN 或 EWOULDBLOCK。
发送字节流
需要向已连接的流式 Socket 写数据时使用 send()。关键不是“调用成功就全部发完”,而是根据返回值推进缓冲区;阻塞 Socket 也可能短写,非阻塞 Socket 还必须处理暂时不可写。
签名
ssize_t send(int sockfd, const void *buf, size_t len, int flags);| 参数 | 类型 | 含义 | 约束 |
|---|---|---|---|
sockfd |
int |
已连接 Socket 的文件描述符 | TCP 通常应先完成 connect() 或 accept() |
buf |
const void * |
待发送数据起始地址 | 在调用返回前必须保持可读 |
len |
size_t |
希望发送的字节数 | 可大于本次实际发送量 |
flags |
int |
本次发送行为标志 | 不需要特殊行为时传 0 |
返回与错误
返回正数时,该值只是本次实际接受的字节数,应从 buf 向后推进相同长度后继续发送剩余数据。返回 -1 表示失败,并通过 errno 判断原因。
阻塞模式下,被信号中断且尚未完成发送时可能得到 EINTR,通常可重试。非阻塞模式下,发送缓冲区暂时没有空间时会得到 EAGAIN 或 EWOULDBLOCK,应等待 Socket 再次可写,而不是忙循环。
完整示例
下面用 socketpair() 创建一对已连接的流式 Socket,并循环调用 send(),直到整个缓冲区都被接受。示例可在提供 POSIX Socket API 的 Unix 类系统上运行。
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
static int send_all(int fd, const void *data, size_t len) {
const unsigned char *p = data;
size_t sent = 0;
while (sent < len) {
ssize_t n = send(fd, p + sent, len - sent, 0);
if (n > 0) {
sent += (size_t)n; // 只推进本次真正发送成功的字节数
continue;
}
if (n < 0 && errno == EINTR) {
continue; // 信号中断后重试剩余数据
}
perror("send");
return -1;
}
return 0;
}
int main(void) {
int sv[2];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
perror("socketpair");
return EXIT_FAILURE;
}
const char message[] = "hello socket";
if (send_all(sv[0], message, sizeof(message) - 1) == -1) {
close(sv[0]);
close(sv[1]);
return EXIT_FAILURE;
}
char buf[32] = {0};
ssize_t n = recv(sv[1], buf, sizeof(buf) - 1, 0);
if (n == -1) {
perror("recv");
close(sv[0]);
close(sv[1]);
return EXIT_FAILURE;
}
printf("received %zd bytes: %.*s\n", n, (int)n, buf);
close(sv[0]);
close(sv[1]);
return EXIT_SUCCESS;
}预期输出:
received 12 bytes: hello socket非阻塞与边界
非阻塞 Socket 出现 EAGAIN 或 EWOULDBLOCK 时,应把尚未发送的数据保留在应用缓冲区,并在 poll()、select()、epoll 等机制报告可写后继续发送。不要把这两个错误当成连接失败。
TCP 是字节流协议,连续多次 send() 的数据可能被对端一次 recv() 合并,也可能被拆成多次读取;业务消息边界必须由应用协议自行定义。flags 支持哪些值以及 SIGPIPE 的控制方式存在平台差异,编写跨平台代码时应以目标系统文档为准。
ssize_t recv(int sockfd, void *buf, size_t len, int flags);从已连接 Socket 读取数据;返回 0 通常表示对端已完成有序关闭,正数只代表本次取得的数据量,不对应一次完整业务消息。
接收字节流
需要从已连接的流式 Socket 读取数据时使用 recv()。判断结果时必须区分正数、0 和 -1:正数只是本次收到的字节数,0 在请求长度大于零时通常表示对端已经有序关闭发送方向。
签名
ssize_t recv(int sockfd, void *buf, size_t len, int flags);| 参数 | 类型 | 含义 | 约束 |
|---|---|---|---|
sockfd |
int |
已连接 Socket 的文件描述符 | TCP 通常来自 connect() 或 accept() |
buf |
void * |
接收数据写入的位置 | 至少可写入 len 字节 |
len |
size_t |
缓冲区可接收的最大字节数 | 返回值不会超过该值 |
flags |
int |
本次接收行为标志 | 普通读取通常传 0 |
返回与错误
返回正数表示本次实际写入 buf 的字节数。对于 TCP,这个长度与发送方单次 send() 的长度没有一一对应关系,因此不能把一次 recv() 当成一条完整业务消息。
当 len 大于零且已缓存数据全部读完后,返回 0 通常表示对端执行了有序关闭,此后不应继续等待该方向产生新的普通字节流数据。返回 -1 表示失败,并通过 errno 获取原因。
阻塞调用可能因信号得到 EINTR;非阻塞 Socket 暂时没有数据时通常返回 -1,并将 errno 设为 EAGAIN 或 EWOULDBLOCK。这些状态表示“现在没有数据”,不等于连接已经关闭。
完整示例
下面先向一端写入数据并关闭其发送方向,再从另一端读取。第一次 recv() 取得已有字节,第二次在数据耗尽后返回 0,从而演示 EOF 的判断方式。
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
int main(void) {
int sv[2];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
perror("socketpair");
return EXIT_FAILURE;
}
const char message[] = "hello";
ssize_t written = send(sv[0], message, sizeof(message) - 1, 0);
if (written != (ssize_t)(sizeof(message) - 1)) {
perror("send");
close(sv[0]);
close(sv[1]);
return EXIT_FAILURE;
}
// 关闭发送方向;接收方读完已有数据后会观察到 EOF。
if (shutdown(sv[0], SHUT_WR) == -1) {
perror("shutdown");
return EXIT_FAILURE;
}
char buf[16];
ssize_t n;
do {
n = recv(sv[1], buf, sizeof(buf), 0);
} while (n < 0 && errno == EINTR);
if (n > 0) {
printf("received %zd bytes: %.*s\n", n, (int)n, buf);
} else if (n == 0) {
puts("peer closed before data arrived");
} else {
perror("recv");
return EXIT_FAILURE;
}
// 已有数据读尽后再次读取,0 表示对端有序结束发送。
n = recv(sv[1], buf, sizeof(buf), 0);
printf("next recv returned %zd\n", n);
close(sv[0]);
close(sv[1]);
return EXIT_SUCCESS;
}预期输出:
received 5 bytes: hello
next recv returned 0消息边界与非阻塞读取
TCP 只提供有序字节流。一个应用消息可能被拆成多次 recv(),多个应用消息也可能一次被读入同一缓冲区。协议需要依靠固定长度、长度字段、分隔符或其他明确规则自行恢复消息边界。
非阻塞模式遇到 EAGAIN 或 EWOULDBLOCK 时,应返回事件循环并等待下一次可读通知。即使使用某些要求尽量填满缓冲区的接收标志,也不能把“请求读取 len 字节”理解成任何情况下都会一次返回 len 字节;信号、关闭和错误都可能使调用提前返回。
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);向指定目标地址发送一个数据报;适合无连接 UDP 场景,单次调用保留数据报边界,但可能受报文长度和网络条件限制。
发送 UDP 数据报
需要在未连接的 UDP socket 上把一个完整数据报发往指定目标时使用 sendto。调用成功只表示内核接受了这次发送请求,不代表对端已经收到;调用方必须检查返回值并按 errno 处理失败。
签名
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen);sendto 适用于 SOCK_DGRAM 等按消息传输的 socket。对未连接 UDP socket,dest_addr 和 addrlen 指定本次数据报的目标地址。
参数
| 参数 | 类型 | 含义 | 约束 |
|---|---|---|---|
sockfd |
int |
已创建的 socket 文件描述符 | UDP 通常由 socket(AF_INET/AF_INET6, SOCK_DGRAM, 0) 创建 |
buf |
const void * |
待发送数据起始地址 | len 大于 0 时应指向至少 len 字节可读内存 |
len |
size_t |
本次数据报负载长度 | UDP 保留一次调用对应一个数据报的边界;过大时可能失败 |
flags |
int |
本次发送标志 | 不需要特殊行为时传 0 |
dest_addr |
const struct sockaddr * |
目标地址 | 实际对象通常是 sockaddr_in 或 sockaddr_in6,调用时转换指针类型 |
addrlen |
socklen_t |
目标地址结构长度 | 必须与 dest_addr 指向的地址族结构匹配 |
返回与错误
成功时返回已接受发送的字节数;UDP 数据报不会像 TCP 字节流那样由一次 sendto 部分发送后再续发。失败时返回 -1 并设置 errno。常见情况包括无效描述符或地址、非阻塞 socket 暂时不可写、信号中断,以及数据报超过本机或路径允许大小而触发 EMSGSIZE。
长度为 0 的 UDP 数据报也是合法数据报,因此返回 0 不等同于“连接关闭”。即使返回值等于 len,UDP 仍不提供端到端到达、顺序或重传保证。
完整示例
下面在本机创建一个 UDP 接收 socket,再用 sendto 向它发送 hello udp,最后从接收 socket 读取数据验证发送结果。示例端口 39001 是固定测试值;若已被占用,请同时修改绑定地址和目标地址中的端口。
cat > sendto_demo.c <<'EOF'
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
int main(void) {
int rx = socket(AF_INET, SOCK_DGRAM, 0);
int tx = socket(AF_INET, SOCK_DGRAM, 0);
if (rx < 0 || tx < 0) { perror("socket"); return 1; }
struct sockaddr_in addr = {
.sin_family = AF_INET,
.sin_port = htons(39001),
.sin_addr.s_addr = htonl(INADDR_LOOPBACK)
};
if (bind(rx, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
perror("bind"); return 1;
}
const char msg[] = "hello udp";
ssize_t sent = sendto(tx, msg, sizeof(msg) - 1, 0,
(struct sockaddr *)&addr, sizeof(addr));
if (sent < 0) { perror("sendto"); return 1; }
char buf[32];
ssize_t got = recv(rx, buf, sizeof(buf) - 1, 0);
if (got < 0) { perror("recv"); return 1; }
buf[got] = '\0';
printf("sent=%zd received=%zd data=%s\n", sent, got, buf);
close(tx);
close(rx);
return 0;
}
EOF
cc -Wall -Wextra -O2 sendto_demo.c -o sendto_demo
./sendto_demo预期输出:
sent=9 received=9 data=hello udp该输出验证的是本机 socket 间的数据报发送与接收;生产环境中仍需由应用层确认远端是否实际处理成功。
边界与兼容性
在已经通过 connect 固定默认对端的 UDP socket 上,通常优先使用 send;需要每次指定不同目标时使用 sendto。IPv4 与 IPv6 必须分别传入与地址族匹配的结构和长度。非阻塞模式下遇到 EAGAIN 或 EWOULDBLOCK 应等待可写事件后重试,不要把 UDP 的成功返回解释成可靠交付确认。
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *restrict src_addr, socklen_t *restrict addrlen);读取一个 UDP 数据报并可同时取得发送端地址;缓冲区不足时需要依据具体语义处理截断风险,调用者应检查返回值和 errno。
接收 UDP 数据报
需要从 UDP socket 读取一个完整数据报并同时取得发送端地址时使用 recvfrom。一次调用最多处理一个数据报;调用方应初始化来源地址长度、检查返回值,并明确处理缓冲区不足和非阻塞读取失败。
签名
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *restrict src_addr,
socklen_t *restrict addrlen);src_addr 用于接收发送端地址,addrlen 是输入输出参数:调用前写入缓冲区可容纳的地址结构大小,返回后其中保存内核实际写入或需要描述的地址长度。若不关心来源地址,可传 NULL 并同时把 addrlen 传为 NULL。
参数
| 参数 | 类型 | 含义 | 约束 |
|---|---|---|---|
sockfd |
int |
用于接收的 socket 文件描述符 | UDP 通常先 bind 到本地地址和端口 |
buf |
void * |
接收缓冲区 | 应至少可写 len 字节 |
len |
size_t |
接收缓冲区容量 | 小于数据报长度时会产生截断风险 |
flags |
int |
本次接收标志 | 常规阻塞读取传 0;非阻塞可使用平台支持的相应标志 |
src_addr |
struct sockaddr * |
输出发送端地址 | 常见实际对象为 sockaddr_in 或 sockaddr_in6 |
addrlen |
socklen_t * |
地址长度输入输出参数 | 调用前初始化,调用后读取更新后的长度 |
返回与错误
成功时返回写入缓冲区的字节数;失败时返回 -1 并设置 errno。阻塞 socket 会等待数据到达,非阻塞 socket 在当前无数据时通常返回 -1,并令 errno 为 EAGAIN 或 EWOULDBLOCK;被信号中断时可能得到 EINTR。
UDP 数据报可能合法地包含 0 字节负载,所以 recvfrom 返回 0 对 UDP 不表示 EOF。若数据报大于 len,超出缓冲区的部分不会自动留给下一次调用;应用需要通过足够大的缓冲区,或使用目标平台提供的截断检测机制来避免静默丢失尾部数据。
完整示例
下面在同一进程中先创建并绑定接收 socket,再从另一个 UDP socket 发出测试数据报,随后用 recvfrom 读取正文和来源 IPv4 地址。示例端口 39001 是固定测试值;若已被占用,请同时修改绑定端口和发送目标端口。
cat > recvfrom_demo.c <<'EOF'
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
int main(void) {
int rx = socket(AF_INET, SOCK_DGRAM, 0);
int tx = socket(AF_INET, SOCK_DGRAM, 0);
if (rx < 0 || tx < 0) { perror("socket"); return 1; }
struct sockaddr_in dst = {
.sin_family = AF_INET,
.sin_port = htons(39001),
.sin_addr.s_addr = htonl(INADDR_LOOPBACK)
};
if (bind(rx, (struct sockaddr *)&dst, sizeof(dst)) < 0) {
perror("bind"); return 1;
}
const char msg[] = "hello udp";
if (sendto(tx, msg, sizeof(msg) - 1, 0,
(struct sockaddr *)&dst, sizeof(dst)) < 0) {
perror("sendto"); return 1;
}
char buf[32];
struct sockaddr_in src;
socklen_t src_len = sizeof(src);
ssize_t n = recvfrom(rx, buf, sizeof(buf) - 1, 0,
(struct sockaddr *)&src, &src_len);
if (n < 0) { perror("recvfrom"); return 1; }
buf[n] = '\0';
char ip[INET_ADDRSTRLEN];
if (inet_ntop(AF_INET, &src.sin_addr, ip, sizeof(ip)) == NULL) {
perror("inet_ntop"); return 1;
}
printf("received=%zd source=%s data=%s\n", n, ip, buf);
close(tx);
close(rx);
return 0;
}
EOF
cc -Wall -Wextra -O2 recvfrom_demo.c -o recvfrom_demo
./recvfrom_demo预期输出:
received=9 source=127.0.0.1 data=hello udp输出中的来源地址来自 src_addr;真实网络环境下它应按实际发送端地址读取,而不是写死。
边界与兼容性
如果只需要数据、不关心发送方,可把 src_addr 和 addrlen 都设为 NULL;若 UDP socket 已通过 connect 固定对端,也可用 recv 简化调用。处理未知大小的数据报时,不要用 n == len 直接断言一定发生截断,因为它也可能恰好等长;需要精确判断时应采用目标系统明确支持的截断标志或 recvmsg 机制,并按该平台文档解释返回长度。
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);使用 msghdr 与 iovec 一次发送多个非连续缓冲区,并可携带辅助数据;适合零散 Buffer 聚合、控制消息和高级 Socket 场景。
sendmsg
当一次发送需要拼接多个非连续缓冲区,或还要携带目标地址、辅助数据时查 sendmsg。它把 msghdr 中的多个 iovec 按顺序作为一次发送提交给内核,避免调用方先手工合并缓冲区。
签名
#include <sys/socket.h>
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);参数
| 参数 | 类型 | 必填 | 含义与约束 |
|---|---|---|---|
sockfd |
int |
是 | 已创建的 Socket 描述符;是否需要先 connect 取决于 Socket 类型和 msg_name 是否提供目标地址。 |
msg |
const struct msghdr * |
是 | 指向消息描述结构;至少应正确设置负载相关的 msg_iov 与 msg_iovlen。 |
flags |
int |
是 | 本次发送的标志位;传 0 使用默认行为。可用标志随操作系统和协议族而异。 |
msghdr 中最常用的字段是:msg_name/msg_namelen 指定未连接数据报的目标地址,msg_iov/msg_iovlen 描述待发送的缓冲区数组,msg_control/msg_controllen 携带 ancillary data。发送时不要把 msg_flags 当作输入标志使用。
返回与错误
成功时返回本次实际发送的字节数;失败返回 -1 并设置 errno。对 SOCK_STREAM,返回值可能小于所有 iovec 长度之和,调用方必须继续发送剩余数据;消息型 Socket 通常以整条消息为单位处理,消息过大可能以 EMSGSIZE 失败。
常见失败还包括 EINTR、非阻塞 Socket 下的 EAGAIN/EWOULDBLOCK,以及连接状态异常导致的 ENOTCONN 或 EPIPE。具体错误集合取决于协议族和平台。
完整示例
下面用 Unix 域 SOCK_DGRAM 的 socketpair 把两个非连续缓冲区一次发送出去。
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
#include <stdio.h>
int main(void) {
int sv[2];
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sv) == -1) {
perror("socketpair");
return 1;
}
char part1[] = "hello ";
char part2[] = "world";
struct iovec iov[2] = {
{ .iov_base = part1, .iov_len = sizeof(part1) - 1 },
{ .iov_base = part2, .iov_len = sizeof(part2) - 1 }
};
struct msghdr msg = {0};
msg.msg_iov = iov;
msg.msg_iovlen = 2;
ssize_t sent = sendmsg(sv[0], &msg, 0);
if (sent == -1) {
perror("sendmsg");
return 1;
}
char buf[32] = {0};
ssize_t received = recv(sv[1], buf, sizeof(buf) - 1, 0);
if (received == -1) {
perror("recv");
return 1;
}
printf("sent=%zd received=%zd data=%s\n", sent, received, buf);
close(sv[0]);
close(sv[1]);
return 0;
}保存为 sendmsg_demo.c 后编译并运行:
cc -Wall -Wextra -O2 sendmsg_demo.c -o sendmsg_demo
./sendmsg_demo预期输出:
sent=11 received=11 data=hello world边界与兼容性
iovec 数量受系统上限约束,需要时可用 sysconf(_SC_IOV_MAX) 查询。SOCK_STREAM 不保留消息边界,因此一次 sendmsg 不代表对端一次 recvmsg 就能完整取回同样的分段。辅助数据的格式与支持项具有平台和协议差异,使用 CMSG_* 宏解析或构造时应以目标系统头文件和手册为准。
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);按照 msghdr 与 iovec 接收分散缓冲区中的数据,并能读取 ancillary data;常用于 Unix 域 Socket、控制消息和协议扩展处理。
recvmsg
当一次接收需要把数据直接分散写入多个缓冲区,或还要读取来源地址、辅助数据和截断状态时查 recvmsg。它让调用方用一个 msghdr 同时取得负载与消息元数据。
签名
#include <sys/socket.h>
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);参数
| 参数 | 类型 | 必填 | 含义与约束 |
|---|---|---|---|
sockfd |
int |
是 | 已创建并可接收数据的 Socket 描述符。 |
msg |
struct msghdr * |
是 | 输入时提供接收缓冲区及其容量,返回时其中的地址长度、控制数据长度和 msg_flags 会反映实际结果。 |
flags |
int |
是 | 本次接收的行为标志;传 0 使用默认行为。MSG_PEEK、MSG_WAITALL 等标志的细节需按目标平台确认。 |
msg_iov/msg_iovlen 描述多个接收缓冲区;msg_name/msg_namelen 可接收对端地址;msg_control/msg_controllen 提供 ancillary data 的存放空间。调用返回后应检查 msg_flags,尤其是 MSG_TRUNC 和 MSG_CTRUNC。
返回与错误
成功时返回本次接收的字节数;失败返回 -1 并设置 errno。对流式 Socket,返回 0 通常表示对端已执行有序关闭;对允许零长度消息的消息型 Socket,0 也可能表示收到了一条零长度消息,因此要结合 Socket 类型判断。
常见失败包括 EINTR、非阻塞 Socket 下的 EAGAIN/EWOULDBLOCK、无效参数导致的 EINVAL 等。若消息大于所有 iovec 的总容量,消息型 Socket 可能发生截断,并通过 msg_flags 中的 MSG_TRUNC 暴露;返回值对截断消息的具体语义还受平台和传入标志影响。
完整示例
下面把一个数据报分散接收到两个独立缓冲区中,再按顺序读取结果。
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
#include <stdio.h>
int main(void) {
int sv[2];
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sv) == -1) {
perror("socketpair");
return 1;
}
const char payload[] = "hello world";
if (send(sv[0], payload, sizeof(payload) - 1, 0) == -1) {
perror("send");
return 1;
}
char first[6] = {0};
char second[7] = {0};
struct iovec iov[2] = {
{ .iov_base = first, .iov_len = 5 },
{ .iov_base = second, .iov_len = 6 }
};
struct msghdr msg = {0};
msg.msg_iov = iov;
msg.msg_iovlen = 2;
ssize_t received = recvmsg(sv[1], &msg, 0);
if (received == -1) {
perror("recvmsg");
return 1;
}
printf("received=%zd data=%s%s flags=0x%x\n",
received, first, second, msg.msg_flags);
close(sv[0]);
close(sv[1]);
return 0;
}保存为 recvmsg_demo.c 后编译并运行:
cc -Wall -Wextra -O2 recvmsg_demo.c -o recvmsg_demo
./recvmsg_demo预期输出:
received=11 data=hello world flags=0x0边界与兼容性
recvmsg 只负责把本次可交付的数据按 iovec 顺序填充,并不会为 SOCK_STREAM 恢复应用层消息边界。处理辅助数据时必须按返回后的 msg_controllen 和 CMSG_* 宏遍历,且要检查 MSG_CTRUNC,否则可能把被截断的控制消息误当成完整结果。不同系统支持的接收标志和控制消息类型并不完全一致。