C / C++ / 系统课时

编写 UDP 通信程序

编写 UDP 通信程序

UDP 以数据报为单位收发,一次 sendto 对应一个数据报,接收端不会把两个数据报自动合并。本课实现一个可运行的回显程序,并把报文边界、丢失乱序和大小限制落实到代码边界中。

学习目标

  • 使用 sendto、recvfrom 完成无连接 UDP 收发
  • 解释 UDP 如何保留数据报边界,以及缓冲区过小时会发生什么
  • 为丢失、乱序和报文大小设置应用层约束

UDP 保留数据报边界

UDP 与 TCP 最重要的接口差异是:接收端每次 recvfrom 最多取得一个数据报,不会把相邻两个数据报拼成一次返回。零长度 UDP 数据报也是合法消息,因此 recvfrom 返回 0 不能解释成“连接关闭”。

UDP 数据报边界与不可靠传输

UDP 不负责确认、重传、排序或去重。sendto 成功只表示数据已经交给本机内核,并不证明对端收到。若业务必须知道“哪条请求丢了、哪条响应过期”,需要在应用协议中加入请求 ID、序号、超时和幂等规则。

构建一个 UDP 回显程序

下面的 Linux 程序使用 127.0.0.1:9090。服务端循环调用 recvfrom 取得来源地址,再用 sendto 把同一数据报回送;客户端发送一条文本并等待回显。示例把应用层最大数据报限制为 512 字节,并给客户端设置 2 秒接收超时,避免丢包时无限阻塞。

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

#define PORT 9090
#define MAX_DGRAM 512

static void die(const char *msg) {
    perror(msg);
    exit(1);
}

static void run_server(void) {
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd < 0) die("socket");

    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(PORT);
    local.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    if (bind(fd, (struct sockaddr *)&local, sizeof(local)) < 0) die("bind");

    printf("server: listening on 127.0.0.1:%d\n", PORT);
    for (;;) {
        unsigned char buf[MAX_DGRAM];
        struct sockaddr_in peer;
        socklen_t peer_len = sizeof(peer);

        /* Linux 上 MSG_TRUNC 让返回值反映原始数据报长度。 */
        ssize_t n = recvfrom(fd, buf, sizeof(buf), MSG_TRUNC,
                             (struct sockaddr *)&peer, &peer_len);
        if (n < 0 && errno == EINTR) continue;
        if (n < 0) die("recvfrom");

        if ((size_t)n > sizeof(buf)) {
            printf("server: drop oversized datagram (%zd bytes)\n", n);
            continue;
        }

        char ip[INET_ADDRSTRLEN];
        if (!inet_ntop(AF_INET, &peer.sin_addr, ip, sizeof(ip))) die("inet_ntop");
        printf("server: recv %zd bytes from %s:%u\n",
               n, ip, (unsigned)ntohs(peer.sin_port));

        /* 一个 sendto 发送一个完整 UDP 数据报。 */
        ssize_t sent = sendto(fd, buf, (size_t)n, 0,
                              (struct sockaddr *)&peer, peer_len);
        if (sent != n) die("sendto");
    }
}

static void run_client(const char *text) {
    size_t len = strlen(text);
    if (len > MAX_DGRAM) {
        fprintf(stderr, "message too large: max %d bytes\n", MAX_DGRAM);
        exit(2);
    }

    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd < 0) die("socket");

    struct timeval timeout = {.tv_sec = 2, .tv_usec = 0};
    if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0)
        die("setsockopt");

    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(PORT);
    if (inet_pton(AF_INET, "127.0.0.1", &server.sin_addr) != 1) die("inet_pton");

    ssize_t sent = sendto(fd, text, len, 0,
                          (struct sockaddr *)&server, sizeof(server));
    if (sent != (ssize_t)len) die("sendto");
    printf("client: sent %zd bytes\n", sent);

    char buf[MAX_DGRAM + 1];
    ssize_t n = recvfrom(fd, buf, MAX_DGRAM, 0, NULL, NULL);
    if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
        fputs("client: timeout waiting for reply\n", stderr);
        close(fd);
        return;
    }
    if (n < 0) die("recvfrom");

    buf[n] = '\0';
    printf("client: recv %zd bytes: %s\n", n, buf);
    close(fd);
}

int main(int argc, char **argv) {
    if (argc == 2 && strcmp(argv[1], "server") == 0) {
        run_server();
        return 0;
    }
    if (argc == 3 && strcmp(argv[1], "client") == 0) {
        run_client(argv[2]);
        return 0;
    }

    fprintf(stderr, "usage: %s server | %s client MESSAGE\n", argv[0], argv[0]);
    return 2;
}

编译后先在终端 A 启动服务端,再在终端 B 启动客户端:

bash
gcc -Wall -Wextra -O2 udp_echo.c -o udp_echo
# 终端 A
./udp_echo server
# 终端 B
./udp_echo client hello

终端 A 的预期输出:

text
server: listening on 127.0.0.1:9090
server: recv 5 bytes from 127.0.0.1:<PORT>

终端 B 的预期输出:

text
client: sent 5 bytes
client: recv 5 bytes: hello

其中 <PORT> 是客户端由内核分配的临时端口,实际值每次运行可能不同。如果服务端未运行、请求或响应丢失,客户端约 2 秒后会输出 client: timeout waiting for reply;超时只说明在窗口内没有收到响应,不能证明服务端一定没有处理请求。

处理丢失、乱序与超时

回显示例在本机通常很稳定,但真实网络上不能把“没有收到响应”直接解释成服务端没有处理请求:请求可能丢失,响应也可能丢失。需要可靠语义时,应在应用层给每个请求分配唯一 ID,并设置接收超时;只有在操作可安全重试或具备幂等保护时才进行重发。

同样,多个数据报可能以不同于发送顺序的次序到达。若顺序有业务意义,应携带单调递增的序号,由接收端检测缺口、重复或旧包,而不是依赖 recvfrom 的调用顺序推断发送顺序。

控制数据报大小

UDP 协议允许的数据报上限远大于很多实际链路的单帧容量。以无 IPv4 选项的普通 UDP 为例,理论最大有效载荷可到 65507 字节,但接近这个尺寸往往会触发 IP 分片;路径 MTU、隧道和中间设备还可能进一步降低安全大小。因此协议上限不能直接当作应用消息上限。

示例主动限制为 512 字节,并在 Linux 服务端使用 MSG_TRUNC 检测“原始数据报比缓冲区更大”的情况。普通 recvfrom 若缓冲区过小,只会复制可容纳部分,剩余部分会从这个数据报中丢弃,下一次调用不会继续读取它。

UDP 的边界是“一个数据报”,不是“一个连接中的字节位置”。把数据报大小、请求标识、顺序和超时都写进应用协议后,sendto/recvfrom 才能成为可控的通信基础。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

编写 UDP 通信程序

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通