计算机网络- UDP协议详解

草稿难度：中级#计算机网络#TCP/IP

原文：CSDN（历史文章导入，当前状态为草稿）

5. UDP协议详解

与TCP不同，UDP（用户数据报协议）是一种简单的、无连接的传输层协议，它提供了最小的传输服务，没有建立连接、确认、重传或流量控制等机制。UDP的简单性使其在某些应用场景中比TCP更为适用，特别是在实时性要求高、允许少量数据丢失的应用中。本章将深入探讨UDP的原理、特性、实现和应用。

5.1 UDP协议基础

5.1.1 UDP的基本概念

**UDP（User Datagram Protocol，用户数据报协议）**是OSI模型和TCP/IP模型中传输层的一个简单协议，由IETF的RFC 768定义。UDP提供了一种无需建立连接就可以发送封装的IP数据报的方法，它仅提供数据的不可靠传输，即不保证数据的交付、不保证数据的顺序、不保证数据的完整性。

UDP的主要特点包括：

无连接：发送数据前不需要建立连接，减少了延迟和开销
不可靠：不保证数据的交付，可能丢失、重复或乱序
无拥塞控制：发送方可以以任何速率发送数据，不考虑网络拥塞
无流量控制：不考虑接收方的处理能力，可能导致接收方缓冲区溢出
支持广播和多播：可以向多个目的地发送数据
头部开销小：UDP头部只有8个字节，比TCP的20个字节小得多

这些特点使UDP在某些应用场景中比TCP更为适用，特别是在实时性要求高、允许少量数据丢失的应用中，如音视频流媒体、在线游戏、DNS查询等。

5.1.2 UDP报文结构

UDP报文由头部和数据两部分组成。UDP头部非常简单，只有8个字节，包含以下字段：

源端口号（Source Port）：16位，表示发送方的端口号，可选字段（如果不使用，则置为0）
目的端口号（Destination Port）：16位，表示接收方的端口号
长度（Length）：16位，表示UDP头部和数据的总长度（以字节为单位）
校验和（Checksum）：16位，用于检验数据在传输过程中是否有错误，可选字段（如果不使用，则置为0）

UDP报文的结构如下图所示：

 0      7 8     15 16    23 24    31
+--------+--------+--------+--------+
|     Source      |   Destination   |
|      Port       |      Port       |
+--------+--------+--------+--------+
|                 |                 |
|     Length      |    Checksum     |
+--------+--------+--------+--------+
|                                   |
|              Data                 |
|                                   |
+-----------------------------------+

UDP头部的简单性是其一个重要特点，这使得UDP的处理开销很小，适合于对实时性要求高的应用。

5.1.3 UDP校验和计算

UDP的校验和是一个可选字段，用于检验数据在传输过程中是否有错误。校验和的计算包括UDP头部、UDP数据和一个伪头部（Pseudo Header）。伪头部包含源IP地址、目的IP地址、协议号（对于UDP是17）和UDP长度。

校验和的计算方法是：将所有16位字（包括伪头部、UDP头部和数据）进行反码求和，然后取反码。如果计算结果为0，则将校验和设置为全1（0xFFFF）。

校验和的计算过程如下：

构造伪头部，包含源IP地址、目的IP地址、协议号和UDP长度
将伪头部、UDP头部和数据看作是16位字的序列
如果数据的字节数为奇数，则在最后添加一个填充字节（0）
将校验和字段置为0
对所有16位字进行反码求和
取反码，得到校验和
如果计算结果为0，则将校验和设置为全1（0xFFFF）

接收方使用相同的算法计算校验和，如果结果为0，则认为数据完整；否则，认为数据已损坏，将丢弃该数据报。

需要注意的是，UDP的校验和是端到端的，它检查的是从源端到目的端的数据完整性。如果校验和显示数据已损坏，UDP不会请求重传，而是简单地丢弃该数据报，由上层协议或应用程序决定如何处理。

5.1.4 UDP在Linux内核中的实现

在Linux内核中，UDP的实现涉及多个函数和数据结构。以下是一些关键的实现细节：

UDP套接字的创建

UDP套接字的创建通过socket系统调用实现，指定协议族为AF_INET（IPv4）或AF_INET6（IPv6），套接字类型为SOCK_DGRAM，协议为IPPROTO_UDP：

// 创建UDP套接字
int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

在内核中，这个调用最终会调用udp_create函数：

// 简化版的udp_create函数
static int udp_create(struct net *net, struct socket *sock, int protocol, int kern)
{
    struct sock *sk;

    // 创建UDP套接字
    sk = sk_alloc(net, PF_INET, GFP_KERNEL, &udp_prot, kern);
    if (!sk)
        return -ENOMEM;

    // 初始化UDP套接字
    sock_init_data(sock, sk);

    // 设置套接字操作函数
    sock->ops = &udp_ops;

    // 初始化UDP特定的字段
    udp_init_sock(sk);

    return 0;
}

UDP数据的发送

UDP数据的发送通过sendto系统调用实现，指定目的地址和端口：

// 发送UDP数据
sendto(sockfd, buf, len, 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));

在内核中，这个调用最终会调用udp_sendmsg函数：

// 简化版的udp_sendmsg函数
int udp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
{
    struct inet_sock *inet = inet_sk(sk);
    struct udp_sock *up = udp_sk(sk);
    struct flowi4 fl4;
    struct rtable *rt = NULL;
    int err = 0;

    // 设置目的地址和端口
    fl4.daddr = inet->inet_daddr;
    fl4.saddr = inet->inet_saddr;
    fl4.fl4_dport = inet->inet_dport;
    fl4.fl4_sport = inet->inet_sport;

    // 查找路由
    rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
    if (IS_ERR(rt)) {
        err = PTR_ERR(rt);
        goto out;
    }

    // 构建UDP数据报
    err = ip_build_xmit(sk, udp_getfrag, msg->msg_iov, len,
                       &fl4, rt, msg->msg_flags);

out:
    return err ? err : len;
}

UDP数据的接收

UDP数据的接收通过recvfrom系统调用实现，可以获取发送方的地址和端口：

// 接收UDP数据
recvfrom(sockfd, buf, len, 0, (struct sockaddr *)&src_addr, &addrlen);

在内核中，这个调用最终会调用udp_recvmsg函数：

// 简化版的udp_recvmsg函数
int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int noblock,
               int flags, int *addr_len)
{
    struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
    struct sk_buff *skb;
    int copied, err;

    // 从接收队列中获取数据报
    skb = __skb_recv_datagram(sk, flags, &err, &copied);
    if (!skb)
        goto out;

    // 复制数据到用户空间
    copied = skb->len - sizeof(struct udphdr);
    if (copied > len) {
        copied = len;
        msg->msg_flags |= MSG_TRUNC;
    }

    err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov, copied);
    if (err)
        goto out_free;

    // 设置发送方地址和端口
    if (sin) {
        sin->sin_family = AF_INET;
        sin->sin_port = udp_hdr(skb)->source;
        sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
        *addr_len = sizeof(*sin);
    }

    // 释放数据报
    skb_free_datagram(sk, skb);

    return copied;

out_free:
    skb_free_datagram(sk, skb);
out:
    return err;
}

UDP校验和的计算

UDP校验和的计算在udp_csum函数中实现：

// 简化版的udp_csum函数
__wsum udp_csum(struct sk_buff *skb)
{
    __wsum csum = 0;

    // 计算伪头部的校验和
    csum = csum_tcpudp_nofold(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
                             skb->len, IPPROTO_UDP, 0);

    // 计算UDP头部和数据的校验和
    csum = skb_checksum(skb, 0, skb->len, csum);

    return csum;
}

5.1.5 UDP的实际应用

UDP在实际应用中有广泛的用途，特别是在实时性要求高、允许少量数据丢失的应用中。以下是一些典型的应用场景：

音视频流媒体

音视频流媒体是UDP的一个重要应用场景。在音视频传输中，实时性通常比可靠性更重要，少量的数据丢失不会显著影响用户体验，而重传可能导致更严重的延迟和卡顿。

常见的基于UDP的音视频协议包括：

RTP（Real-time Transport Protocol）：用于音视频数据的传输
RTCP（RTP Control Protocol）：与RTP配合使用，提供传输质量反馈
RTSP（Real Time Streaming Protocol）：用于控制流媒体服务器

在线游戏

在线游戏，特别是实时动作游戏，通常使用UDP进行通信。在游戏中，实时性对于玩家体验至关重要，少量的数据丢失可以通过游戏逻辑进行补偿。

游戏中的UDP应用包括：

位置更新：玩家和游戏对象的位置信息
动作命令：玩家的操作指令
游戏状态同步：游戏世界的状态信息

DNS查询

DNS（Domain Name System）查询通常使用UDP进行通信。DNS查询通常是简短的请求和响应，使用UDP可以减少延迟和开销。

DNS查询的过程包括：

客户端向DNS服务器发送UDP查询请求
DNS服务器返回UDP响应，包含域名解析结果
如果响应超过UDP数据报的大小限制，可能会使用TCP进行传输

VoIP通信

VoIP（Voice over IP）通信通常使用UDP进行语音数据的传输。在VoIP中，实时性对于通话质量至关重要，少量的数据丢失可以通过音频编解码器进行补偿。

VoIP中的UDP应用包括：

SIP（Session Initiation Protocol）：用于建立和管理通话会话
RTP（Real-time Transport Protocol）：用于传输语音数据
RTCP（RTP Control Protocol）：提供传输质量反馈

网络时间同步

NTP（Network Time Protocol）使用UDP进行时间同步。NTP客户端向NTP服务器发送UDP请求，服务器返回当前时间，客户端根据往返时间计算时钟偏移。

NTP的工作过程包括：

客户端向NTP服务器发送UDP请求，包含发送时间
NTP服务器返回UDP响应，包含接收时间、发送时间和当前时间
客户端根据这些时间戳计算时钟偏移和往返延迟

UDP的简单性和低延迟特性使其在这些应用场景中比TCP更为适用。然而，UDP的不可靠性也要求应用程序自行处理数据丢失、重复和乱序等问题，这增加了应用程序的复杂性。

5.2 UDP编程实践

UDP编程相对简单，因为不需要处理连接的建立和维护。本节将介绍UDP编程的基本步骤、常用API和一些实践技巧。

5.2.1 UDP套接字API

UDP编程主要使用套接字API，包括套接字的创建、绑定、发送和接收等操作。以下是一些常用的UDP套接字API：

套接字创建

使用socket函数创建UDP套接字：

int socket(int domain, int type, int protocol);

参数说明：

domain：协议族，通常为AF_INET（IPv4）或AF_INET6（IPv6）
type：套接字类型，对于UDP应为SOCK_DGRAM
protocol：协议，通常为IPPROTO_UDP或0（系统会根据type自动选择）

返回值：

成功：返回一个非负整数，表示套接字描述符
失败：返回-1，并设置errno

示例：

// 创建UDP套接字
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
    perror("socket");
    exit(EXIT_FAILURE);
}

套接字绑定

使用bind函数将套接字绑定到特定的地址和端口：

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

参数说明：

sockfd：套接字描述符
addr：指向包含地址信息的结构体的指针
addrlen：addr结构体的长度

返回值：

成功：返回0
失败：返回-1，并设置errno

示例：

// 绑定UDP套接字到特定地址和端口
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);  // 绑定到所有可用接口
addr.sin_port = htons(8888);  // 绑定到端口8888

if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
    perror("bind");
    exit(EXIT_FAILURE);
}

数据发送

使用sendto函数发送UDP数据：

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
              const struct sockaddr *dest_addr, socklen_t addrlen);

参数说明：

sockfd：套接字描述符
buf：指向要发送的数据的指针
len：要发送的数据的长度
flags：发送选项，通常为0
dest_addr：指向目的地址信息的结构体的指针
addrlen：dest_addr结构体的长度

返回值：

成功：返回发送的字节数
失败：返回-1，并设置errno

示例：

// 发送UDP数据
struct sockaddr_in dest_addr;
memset(&dest_addr, 0, sizeof(dest_addr));
dest_addr.sin_family = AF_INET;
dest_addr.sin_addr.s_addr = inet_addr("192.168.1.100");  // 目的IP地址
dest_addr.sin_port = htons(8888);  // 目的端口

const char *message = "Hello, UDP!";
ssize_t sent_bytes = sendto(sockfd, message, strlen(message), 0,
                           (struct sockaddr *)&dest_addr, sizeof(dest_addr));
if (sent_bytes < 0) {
    perror("sendto");
    exit(EXIT_FAILURE);
}

数据接收

使用recvfrom函数接收UDP数据：

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                struct sockaddr *src_addr, socklen_t *addrlen);

参数说明：

sockfd：套接字描述符
buf：指向接收缓冲区的指针
len：接收缓冲区的大小
flags：接收选项，通常为0
src_addr：指向源地址信息的结构体的指针，用于存储发送方的地址
addrlen：指向src_addr结构体长度的指针，调用前设置为src_addr的大小，调用后更新为实际的地址长度

返回值：

成功：返回接收的字节数
失败：返回-1，并设置errno

示例：

// 接收UDP数据
char buffer[1024];
struct sockaddr_in src_addr;
socklen_t src_addr_len = sizeof(src_addr);

ssize_t recv_bytes = recvfrom(sockfd, buffer, sizeof(buffer), 0,
                             (struct sockaddr *)&src_addr, &src_addr_len);
if (recv_bytes < 0) {
    perror("recvfrom");
    exit(EXIT_FAILURE);
}

// 添加字符串结束符
buffer[recv_bytes] = '\0';

// 打印接收到的数据和发送方信息
printf("Received %zd bytes from %s:%d: %s\n",
       recv_bytes, inet_ntoa(src_addr.sin_addr), ntohs(src_addr.sin_port), buffer);

套接字关闭

使用close函数关闭UDP套接字：

int close(int fd);

参数说明：

fd：文件描述符，这里是套接字描述符

返回值：

成功：返回0
失败：返回-1，并设置errno

示例：

// 关闭UDP套接字
if (close(sockfd) < 0) {
    perror("close");
    exit(EXIT_FAILURE);
}

5.2.2 UDP服务器和客户端示例

下面是一个简单的UDP服务器和客户端示例，展示了UDP编程的基本流程。

UDP服务器

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

#define PORT 8888
#define BUFFER_SIZE 1024

int main() {
    int sockfd;
    struct sockaddr_in server_addr, client_addr;
    char buffer[BUFFER_SIZE];
    socklen_t client_addr_len = sizeof(client_addr);

    // 创建UDP套接字
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 初始化服务器地址结构
    memset(&server_addr, 0, sizeof(server_addr));
    memset(&client_addr, 0, sizeof(client_addr));

    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT);

    // 绑定套接字到指定端口
    if (bind(sockfd, (const struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    printf("UDP Server running on port %d...\n", PORT);

    while (1) {
        // 接收数据
        ssize_t recv_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
                                   (struct sockaddr *)&client_addr, &client_addr_len);

        if (recv_len < 0) {
            perror("recvfrom failed");
            exit(EXIT_FAILURE);
        }

        // 添加字符串结束符
        buffer[recv_len] = '\0';

        // 打印接收到的数据和客户端信息
        printf("Received from %s:%d: %s\n",
               inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), buffer);

        // 发送响应
        const char *response = "Hello from UDP server!";
        sendto(sockfd, response, strlen(response), 0,
              (const struct sockaddr *)&client_addr, client_addr_len);
    }

    close(sockfd);
    return 0;
}

UDP客户端

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

#define PORT 8888
#define BUFFER_SIZE 1024
#define SERVER_IP "127.0.0.1"

int main() {
    int sockfd;
    struct sockaddr_in server_addr;
    char buffer[BUFFER_SIZE];
    socklen_t server_addr_len = sizeof(server_addr);

    // 创建UDP套接字
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 初始化服务器地址结构
    memset(&server_addr, 0, sizeof(server_addr));

    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
    server_addr.sin_port = htons(PORT);

    // 发送数据
    const char *message = "Hello from UDP client!";
    sendto(sockfd, message, strlen(message), 0,
          (const struct sockaddr *)&server_addr, server_addr_len);

    printf("Message sent: %s\n", message);

    // 接收响应
    ssize_t recv_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
                               (struct sockaddr *)&server_addr, &server_addr_len);

    if (recv_len < 0) {
        perror("recvfrom failed");
        exit(EXIT_FAILURE);
    }

    // 添加字符串结束符
    buffer[recv_len] = '\0';

    // 打印接收到的响应
    printf("Server response: %s\n", buffer);

    close(sockfd);
    return 0;
}

5.2.3 UDP编程的常见问题与解决方案

UDP编程虽然相对简单，但也存在一些常见问题，需要特别注意。以下是一些常见问题及其解决方案：

数据包大小限制

UDP数据包的大小受到IP层MTU（最大传输单元）的限制，通常为1500字节。如果数据包大小超过MTU，IP层会进行分片，这可能导致性能下降和丢包率增加。

解决方案：

控制应用层数据的大小，确保UDP数据包不超过MTU
在应用层实现数据分片和重组，避免IP层分片
使用路径MTU发现（PMTUD）机制，动态调整数据包大小

示例代码（应用层分片）：

#define MAX_PACKET_SIZE 1400  // 小于MTU的安全值
#define MESSAGE_ID_SIZE 8     // 消息ID的大小

// 发送大数据
void send_large_data(int sockfd, const struct sockaddr *dest_addr, socklen_t addrlen,
                    const void *data, size_t data_len) {
    // 生成唯一的消息ID
    char message_id[MESSAGE_ID_SIZE];
    generate_message_id(message_id);

    // 计算分片数量
    int total_fragments = (data_len + MAX_PACKET_SIZE - 1) / MAX_PACKET_SIZE;

    // 分片发送
    for (int i = 0; i < total_fragments; i++) {
        // 计算当前分片的数据大小
        size_t fragment_size = (i == total_fragments - 1) ?
                              (data_len - i * MAX_PACKET_SIZE) :
                              MAX_PACKET_SIZE;

        // 构建分片头部
        char header[MESSAGE_ID_SIZE + 8];  // 消息ID + 分片信息
        memcpy(header, message_id, MESSAGE_ID_SIZE);
        *(int *)(header + MESSAGE_ID_SIZE) = i;  // 分片索引
        *(int *)(header + MESSAGE_ID_SIZE + 4) = total_fragments;  // 总分片数

        // 构建完整的分片数据
        char fragment[MESSAGE_ID_SIZE + 8 + MAX_PACKET_SIZE];
        memcpy(fragment, header, MESSAGE_ID_SIZE + 8);
        memcpy(fragment + MESSAGE_ID_SIZE + 8, (char *)data + i * MAX_PACKET_SIZE, fragment_size);

        // 发送分片
        sendto(sockfd, fragment, MESSAGE_ID_SIZE + 8 + fragment_size, 0, dest_addr, addrlen);
    }
}

数据丢失和重传

UDP不保证数据的可靠传输，数据包可能会丢失。在需要可靠传输的应用中，需要在应用层实现确认和重传机制。

解决方案：

实现简单的确认机制，接收方收到数据后发送确认
实现超时重传机制，发送方在一定时间内没有收到确认就重新发送数据
使用序列号标识数据包，避免重复处理

示例代码（简单的确认和重传机制）：

#define TIMEOUT_MS 500  // 超时时间（毫秒）
#define MAX_RETRIES 3   // 最大重试次数

// 可靠发送
int reliable_send(int sockfd, const struct sockaddr *dest_addr, socklen_t addrlen,
                 const void *data, size_t data_len) {
    // 生成序列号
    static uint32_t seq_num = 0;
    uint32_t current_seq = seq_num++;

    // 构建数据包（序列号 + 数据）
    char packet[sizeof(uint32_t) + data_len];
    *(uint32_t *)packet = htonl(current_seq);
    memcpy(packet + sizeof(uint32_t), data, data_len);

    // 设置接收超时
    struct timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = TIMEOUT_MS * 1000;
    setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));

    // 重试发送
    for (int retry = 0; retry < MAX_RETRIES; retry++) {
        // 发送数据
        sendto(sockfd, packet, sizeof(uint32_t) + data_len, 0, dest_addr, addrlen);

        // 等待确认
        char ack_buffer[sizeof(uint32_t)];
        struct sockaddr_in src_addr;
        socklen_t src_addr_len = sizeof(src_addr);

        ssize_t recv_len = recvfrom(sockfd, ack_buffer, sizeof(ack_buffer), 0,
                                   (struct sockaddr *)&src_addr, &src_addr_len);

        // 检查确认
        if (recv_len == sizeof(uint32_t) && ntohl(*(uint32_t *)ack_buffer) == current_seq) {
            return 0;  // 成功
        }
    }

    return -1;  // 失败
}

// 可靠接收
int reliable_recv(int sockfd, struct sockaddr *src_addr, socklen_t *addrlen,
                 void *data, size_t max_len) {
    // 接收数据
    char packet[sizeof(uint32_t) + max_len];
    ssize_t recv_len = recvfrom(sockfd, packet, sizeof(uint32_t) + max_len, 0,
                               src_addr, addrlen);

    if (recv_len <= sizeof(uint32_t)) {
        return -1;  // 接收失败或数据太短
    }

    // 提取序列号
    uint32_t seq_num = ntohl(*(uint32_t *)packet);

    // 发送确认
    sendto(sockfd, &seq_num, sizeof(seq_num), 0, src_addr, *addrlen);

    // 复制数据
    size_t data_len = recv_len - sizeof(uint32_t);
    memcpy(data, packet + sizeof(uint32_t), data_len);

    return data_len;
}

数据乱序

UDP不保证数据的顺序，数据包可能会乱序到达。在需要有序处理数据的应用中，需要在应用层实现排序机制。

解决方案：

使用序列号标识数据包的顺序
在接收方维护一个缓冲区，按序列号排序数据包
设置一个滑动窗口，只处理窗口内的数据包

示例代码（简单的排序机制）：

#define MAX_BUFFER_PACKETS 1000  // 最大缓冲区数据包数量
#define WINDOW_SIZE 100          // 滑动窗口大小

// 数据包结构
typedef struct {
    uint32_t seq_num;  // 序列号
    size_t data_len;   // 数据长度
    char data[MAX_PACKET_SIZE];  // 数据
} Packet;

// 接收缓冲区
Packet recv_buffer[MAX_BUFFER_PACKETS];
int buffer_count = 0;
uint32_t next_seq_num = 0;  // 期望的下一个序列号

// 添加数据包到缓冲区
void add_packet_to_buffer(const Packet *packet) {
    // 检查缓冲区是否已满
    if (buffer_count >= MAX_BUFFER_PACKETS) {
        return;
    }

    // 检查序列号是否在窗口内
    if (packet->seq_num < next_seq_num ||
        packet->seq_num >= next_seq_num + WINDOW_SIZE) {
        return;
    }

    // 添加到缓冲区
    int i = 0;
    while (i < buffer_count && recv_buffer[i].seq_num < packet->seq_num) {
        i++;
    }

    // 检查是否已存在
    if (i < buffer_count && recv_buffer[i].seq_num == packet->seq_num) {
        return;
    }

    // 插入到正确位置
    for (int j = buffer_count; j > i; j--) {
        recv_buffer[j] = recv_buffer[j - 1];
    }

    recv_buffer[i] = *packet;
    buffer_count++;
}

// 处理缓冲区中的有序数据包
void process_ordered_packets(void (*process_data)(const void *, size_t)) {
    while (buffer_count > 0 && recv_buffer[0].seq_num == next_seq_num) {
        // 处理数据
        process_data(recv_buffer[0].data, recv_buffer[0].data_len);

        // 更新下一个期望的序列号
        next_seq_num++;

        // 移除已处理的数据包
        for (int i = 0; i < buffer_count - 1; i++) {
            recv_buffer[i] = recv_buffer[i + 1];
        }
        buffer_count--;
    }
}

拥塞控制

UDP没有内置的拥塞控制机制，可能会导致网络拥塞和性能下降。在需要高吞吐量的应用中，可能需要在应用层实现简单的拥塞控制。

解决方案：

监控丢包率和往返时间（RTT），动态调整发送速率
实现简单的AIMD（加性增加乘性减少）算法
使用令牌桶或漏桶算法限制发送速率

示例代码（简单的AIMD拥塞控制）：

#define INITIAL_RATE 1000000  // 初始发送速率（字节/秒）
#define MIN_RATE 10000        // 最小发送速率
#define MAX_RATE 10000000     // 最大发送速率
#define RATE_INCREASE 10000   // 每次增加的速率
#define RATE_DECREASE_FACTOR 0.5  // 减少因子

// 拥塞控制状态
typedef struct {
    uint64_t send_rate;  // 当前发送速率（字节/秒）
    uint64_t last_send_time;  // 上次发送时间（微秒）
    uint64_t bytes_sent;  // 已发送字节数
    int loss_detected;  // 是否检测到丢包
} CongestionControl;

// 初始化拥塞控制
void init_congestion_control(CongestionControl *cc) {
    cc->send_rate = INITIAL_RATE;
    cc->last_send_time = get_current_time_us();
    cc->bytes_sent = 0;
    cc->loss_detected = 0;
}

// 检查是否可以发送数据
int can_send(CongestionControl *cc, size_t data_len) {
    uint64_t current_time = get_current_time_us();
    uint64_t time_diff = current_time - cc->last_send_time;

    // 计算在当前速率下可以发送的字节数
    uint64_t allowed_bytes = (cc->send_rate * time_diff) / 1000000;

    if (cc->bytes_sent + data_len <= allowed_bytes) {
        return 1;  // 可以发送
    }

    return 0;  // 不能发送
}

// 更新拥塞控制状态（发送后调用）
void update_on_send(CongestionControl *cc, size_t data_len) {
    cc->bytes_sent += data_len;
}

// 更新拥塞控制状态（周期性调用）
void update_congestion_control(CongestionControl *cc) {
    uint64_t current_time = get_current_time_us();
    uint64_t time_diff = current_time - cc->last_send_time;

    // 每秒更新一次
    if (time_diff >= 1000000) {
        // 重置计数器
        cc->last_send_time = current_time;
        cc->bytes_sent = 0;

        // 根据丢包情况调整发送速率
        if (cc->loss_detected) {
            // 乘性减少
            cc->send_rate = (uint64_t)(cc->send_rate * RATE_DECREASE_FACTOR);
            if (cc->send_rate < MIN_RATE) {
                cc->send_rate = MIN_RATE;
            }
            cc->loss_detected = 0;
        } else {
            // 加性增加
            cc->send_rate += RATE_INCREASE;
            if (cc->send_rate > MAX_RATE) {
                cc->send_rate = MAX_RATE;
            }
        }
    }
}

// 设置丢包标志（检测到丢包时调用）
void set_loss_detected(CongestionControl *cc) {
    cc->loss_detected = 1;
}

UDP编程虽然相对简单，但在实际应用中，通常需要在应用层实现各种机制来弥补UDP的不足，如可靠传输、有序交付、拥塞控制等。这些机制的实现复杂度取决于应用的需求，可以从简单的确认和重传开始，逐步添加更复杂的功能。

5.3 UDP高级特性

除了基本的数据传输功能外，UDP还有一些高级特性，如广播、多播、QoS支持等。这些特性使UDP在特定场景下具有独特的优势。本节将介绍这些高级特性及其应用。

5.3.1 UDP广播

**广播（Broadcasting）**是一种一对多的通信方式，允许一个主机向同一网络中的所有主机发送数据。UDP支持广播，这使得它在局域网内的服务发现、时间同步等场景中非常有用。

广播地址

广播地址是一种特殊的IP地址，用于向网络中的所有主机发送数据。广播地址有两种类型：

有限广播地址：255.255.255.255，用于向当前网络中的所有主机发送数据
指向性广播地址：网络地址的主机部分全为1，如192.168.1.255（对于192.168.1.0/24网络）

启用广播

在使用UDP广播前，需要设置套接字选项SO_BROADCAST，允许发送广播数据包：

int broadcast = 1;
if (setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast)) < 0) {
    perror("setsockopt (SO_BROADCAST)");
    exit(EXIT_FAILURE);
}

广播示例

以下是一个简单的UDP广播示例，展示了如何发送和接收广播数据包：

// 广播发送端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define PORT 8888
#define BROADCAST_ADDR "255.255.255.255"  // 有限广播地址

int main() {
    int sockfd;
    struct sockaddr_in broadcast_addr;

    // 创建UDP套接字
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 启用广播
    int broadcast = 1;
    if (setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast)) < 0) {
        perror("setsockopt (SO_BROADCAST)");
        exit(EXIT_FAILURE);
    }

    // 初始化广播地址结构
    memset(&broadcast_addr, 0, sizeof(broadcast_addr));
    broadcast_addr.sin_family = AF_INET;
    broadcast_addr.sin_addr.s_addr = inet_addr(BROADCAST_ADDR);
    broadcast_addr.sin_port = htons(PORT);

    // 发送广播数据
    const char *message = "Hello, everyone!";
    if (sendto(sockfd, message, strlen(message), 0,
              (struct sockaddr *)&broadcast_addr, sizeof(broadcast_addr)) < 0) {
        perror("sendto failed");
        exit(EXIT_FAILURE);
    }

    printf("Broadcast message sent: %s\n", message);

    close(sockfd);
    return 0;
}

// 广播接收端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define PORT 8888
#define BUFFER_SIZE 1024

int main() {
    int sockfd;
    struct sockaddr_in server_addr, client_addr;
    char buffer[BUFFER_SIZE];
    socklen_t client_addr_len = sizeof(client_addr);

    // 创建UDP套接字
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 启用地址重用
    int reuse = 1;
    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
        perror("setsockopt (SO_REUSEADDR)");
        exit(EXIT_FAILURE);
    }

    // 初始化服务器地址结构
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;  // 绑定到所有接口
    server_addr.sin_port = htons(PORT);

    // 绑定套接字
    if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    printf("Waiting for broadcast messages...\n");

    // 接收广播数据
    ssize_t recv_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
                               (struct sockaddr *)&client_addr, &client_addr_len);

    if (recv_len < 0) {
        perror("recvfrom failed");
        exit(EXIT_FAILURE);
    }

    // 添加字符串结束符
    buffer[recv_len] = '\0';

    // 打印接收到的数据和发送方信息
    printf("Received broadcast from %s:%d: %s\n",
           inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), buffer);

    close(sockfd);
    return 0;
}

广播的应用场景

UDP广播在以下场景中有广泛应用：

服务发现：客户端通过广播查找局域网内的服务器
网络时间同步：时间服务器通过广播向网络中的所有主机发送时间信息
DHCP：DHCP客户端通过广播发送DHCP请求
网络游戏：游戏客户端通过广播查找局域网内的游戏服务器

广播的限制

广播有一些限制和注意事项：

广播通常被限制在局域网内，路由器默认不转发广播数据包
广播可能会导致网络拥塞，特别是在大型网络中
不是所有的网络设备都会处理广播数据包，有些设备可能会丢弃它们
广播不适合安全敏感的应用，因为所有主机都能接收到广播数据

5.3.2 UDP多播

**多播（Multicasting）**是一种一对多的通信方式，允许一个主机向特定组的多个主机发送数据。与广播不同，多播只发送给加入了特定多播组的主机，而不是网络中的所有主机。UDP支持多播，这使得它在流媒体、视频会议等场景中非常有用。

多播地址

多播地址是一种特殊的IP地址，用于标识多播组。IPv4多播地址范围是224.0.0.0到239.255.255.255。其中：

224.0.0.0到224.0.0.255是保留的链路本地地址，用于局域网协议
224.0.1.0到238.255.255.255是全球范围的多播地址
239.0.0.0到239.255.255.255是本地管理的多播地址，用于局域网内的多播

加入多播组

接收多播数据的主机需要加入相应的多播组。这通过设置套接字选项IP_ADD_MEMBERSHIP实现：

struct ip_mreq mreq;
mreq.imr_multiaddr.s_addr = inet_addr("224.0.0.1");  // 多播组地址
mreq.imr_interface.s_addr = INADDR_ANY;  // 本地接口

if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
    perror("setsockopt (IP_ADD_MEMBERSHIP)");
    exit(EXIT_FAILURE);
}

设置多播TTL

多播数据包的生存时间（TTL）决定了数据包可以经过的路由器跳数。默认TTL为1，表示多播数据包不会被路由器转发。可以通过设置套接字选项IP_MULTICAST_TTL修改TTL：

int ttl = 5;  // 设置TTL为5
if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
    perror("setsockopt (IP_MULTICAST_TTL)");
    exit(EXIT_FAILURE);
}

多播示例

以下是一个简单的UDP多播示例，展示了如何发送和接收多播数据包：

// 多播发送端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define PORT 8888
#define MULTICAST_ADDR "224.0.0.1"  // 多播组地址

int main() {
    int sockfd;
    struct sockaddr_in multicast_addr;

    // 创建UDP套接字
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 设置多播TTL
    int ttl = 5;
    if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
        perror("setsockopt (IP_MULTICAST_TTL)");
        exit(EXIT_FAILURE);
    }

    // 初始化多播地址结构
    memset(&multicast_addr, 0, sizeof(multicast_addr));
    multicast_addr.sin_family = AF_INET;
    multicast_addr.sin_addr.s_addr = inet_addr(MULTICAST_ADDR);
    multicast_addr.sin_port = htons(PORT);

    // 发送多播数据
    const char *message = "Hello, multicast group!";
    if (sendto(sockfd, message, strlen(message), 0,
              (struct sockaddr *)&multicast_addr, sizeof(multicast_addr)) < 0) {
        perror("sendto failed");
        exit(EXIT_FAILURE);
    }

    printf("Multicast message sent: %s\n", message);

    close(sockfd);
    return 0;
}

// 多播接收端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define PORT 8888
#define MULTICAST_ADDR "224.0.0.1"  // 多播组地址
#define BUFFER_SIZE 1024

int main() {
    int sockfd;
    struct sockaddr_in server_addr, client_addr;
    char buffer[BUFFER_SIZE];
    socklen_t client_addr_len = sizeof(client_addr);

    // 创建UDP套接字
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 启用地址重用
    int reuse = 1;
    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
        perror("setsockopt (SO_REUSEADDR)");
        exit(EXIT_FAILURE);
    }

    // 初始化服务器地址结构
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;  // 绑定到所有接口
    server_addr.sin_port = htons(PORT);

    // 绑定套接字
    if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    // 加入多播组
    struct ip_mreq mreq;
    mreq.imr_multiaddr.s_addr = inet_addr(MULTICAST_ADDR);
    mreq.imr_interface.s_addr = INADDR_ANY;

    if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
        perror("setsockopt (IP_ADD_MEMBERSHIP)");
        exit(EXIT_FAILURE);
    }

    printf("Joined multicast group %s, waiting for messages...\n", MULTICAST_ADDR);

    // 接收多播数据
    ssize_t recv_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
                               (struct sockaddr *)&client_addr, &client_addr_len);

    if (recv_len < 0) {
        perror("recvfrom failed");
        exit(EXIT_FAILURE);
    }

    // 添加字符串结束符
    buffer[recv_len] = '\0';

    // 打印接收到的数据和发送方信息
    printf("Received multicast from %s:%d: %s\n",
           inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), buffer);

    // 离开多播组
    if (setsockopt(sockfd, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
        perror("setsockopt (IP_DROP_MEMBERSHIP)");
        exit(EXIT_FAILURE);
    }

    close(sockfd);
    return 0;
}

多播的应用场景

UDP多播在以下场景中有广泛应用：

流媒体：IPTV、网络广播等
视频会议：多人视频会议系统
分布式系统：集群节点间的状态同步
网络游戏：多人在线游戏中的状态广播
服务发现：mDNS（多播DNS）、UPnP等协议

多播的优势和限制

多播相比广播和单播有以下优势：

比广播更高效，只发送给加入了多播组的主机
比单播更节省带宽，一次发送可以到达多个目的地
支持跨网络传输，可以通过配置路由器转发多播数据包

多播也有一些限制：

需要网络设备（如路由器、交换机）支持多播
多播路由协议（如PIM、DVMRP）的配置相对复杂
多播数据包可能会被某些网络过滤或限制
多播通常不提供可靠传输，需要在应用层实现可靠性机制

5.3.3 UDP QoS支持

**QoS（Quality of Service，服务质量）**是指网络能够为特定类型的流量提供不同级别的服务的能力。UDP本身不提供QoS保证，但可以通过设置IP头部的服务类型（ToS）或区分服务（DiffServ）字段，向网络设备指示数据包的优先级。

设置ToS/DSCP

可以通过设置套接字选项IP_TOS来设置IP头部的ToS字段：

int tos = 0x10;  // 低延迟
if (setsockopt(sockfd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) {
    perror("setsockopt (IP_TOS)");
    exit(EXIT_FAILURE);
}

ToS字段的常用值包括：

0x00：普通服务
0x10：最小延迟
0x08：最大吞吐量
0x04：最大可靠性
0x02：最小成本

在现代网络中，ToS字段通常被解释为DSCP（Differentiated Services Code Point）值，用于实现区分服务。DSCP值定义了不同的服务类别，如：

0x00（0）：尽力而为（默认）
0x08（8）：CS1，低优先级数据
0x10（16）：CS2，高优先级数据
0x18（24）：CS3，语音信令
0x20（32）：CS4，视频
0x28（40）：CS5，语音数据
0x30（48）：CS6，网络控制

QoS示例

以下是一个设置UDP数据包QoS的示例：

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

#define PORT 8888
#define SERVER_IP "192.168.1.100"

int main() {
    int sockfd;
    struct sockaddr_in server_addr;

    // 创建UDP套接字
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 设置QoS（最小延迟）
    int tos = 0x10;  // 最小延迟
    if (setsockopt(sockfd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) {
        perror("setsockopt (IP_TOS)");
        exit(EXIT_FAILURE);
    }

    // 初始化服务器地址结构
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
    server_addr.sin_port = htons(PORT);

    // 发送数据
    const char *message = "High priority message";
    if (sendto(sockfd, message, strlen(message), 0,
              (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("sendto failed");
        exit(EXIT_FAILURE);
    }

    printf("Message sent with high priority: %s\n", message);

    close(sockfd);
    return 0;
}

QoS的应用场景

UDP QoS在以下场景中有重要应用：

VoIP通信：语音数据需要低延迟和低抖动
视频流：视频数据需要高带宽和相对低的延迟
在线游戏：游戏数据需要低延迟和低丢包率
远程控制：控制命令需要高可靠性和低延迟
混合流量环境：在同一网络中传输不同类型的流量时，需要区分优先级

QoS的限制

UDP QoS有一些限制和注意事项：

QoS设置只是一个提示，网络设备可能不会遵循这些设置
QoS效果取决于网络路径上所有设备的支持和配置
在互联网环境中，QoS通常难以端到端保证
过度使用高优先级可能导致网络拥塞和性能下降

5.3.4 UDP性能优化

UDP的简单性使其在某些场景下具有性能优势，但也需要一些优化技巧来充分发挥其潜力。以下是一些UDP性能优化的方法：

缓冲区大小优化

适当增大UDP套接字的发送和接收缓冲区大小，可以提高吞吐量和减少丢包：

// 设置发送缓冲区大小
int sendbuf = 262144;  // 256KB
if (setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &sendbuf, sizeof(sendbuf)) < 0) {
    perror("setsockopt (SO_SNDBUF)");
    exit(EXIT_FAILURE);
}

// 设置接收缓冲区大小
int recvbuf = 262144;  // 256KB
if (setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &recvbuf, sizeof(recvbuf)) < 0) {
    perror("setsockopt (SO_RCVBUF)");
    exit(EXIT_FAILURE);
}

数据包大小优化

选择合适的数据包大小，避免IP分片，可以提高传输效率：

以太网MTU通常为1500字节，减去IP头部（20字节）和UDP头部（8字节），UDP数据的最大大小为1472字节
如果数据包需要经过VPN或其他隧道，MTU可能更小，需要相应调整数据包大小
对于需要高吞吐量的应用，可以使用接近MTU的数据包大小
对于需要低延迟的应用，可以使用较小的数据包大小

批量处理

批量发送和接收数据包可以减少系统调用次数，提高效率：

// 批量发送
for (int i = 0; i < batch_size; i++) {
    sendto(sockfd, data[i], data_len[i], 0, dest_addr, addrlen);
}

// 批量接收
fd_set readfds;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;

while (1) {
    FD_ZERO(&readfds);
    FD_SET(sockfd, &readfds);

    int ready = select(sockfd + 1, &readfds, NULL, NULL, &tv);
    if (ready <= 0) {
        break;  // 没有数据可读或出错
    }

    recvfrom(sockfd, buffer, buffer_size, 0, src_addr, addrlen);
    // 处理接收到的数据
}

非阻塞I/O

使用非阻塞I/O可以避免在I/O操作上阻塞，提高并发处理能力：

// 设置非阻塞模式
int flags = fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);

// 非阻塞发送
ssize_t sent = sendto(sockfd, data, data_len, 0, dest_addr, addrlen);
if (sent < 0) {
    if (errno == EAGAIN || errno == EWOULDBLOCK) {
        // 发送缓冲区已满，稍后重试
    } else {
        // 其他错误
        perror("sendto");
    }
}

// 非阻塞接收
ssize_t received = recvfrom(sockfd, buffer, buffer_size, 0, src_addr, addrlen);
if (received < 0) {
    if (errno == EAGAIN || errno == EWOULDBLOCK) {
        // 没有数据可读，稍后重试
    } else {
        // 其他错误
        perror("recvfrom");
    }
}

多线程处理

使用多线程可以并行处理UDP数据包，提高吞吐量：

// 创建接收线程
pthread_t recv_thread;
pthread_create(&recv_thread, NULL, recv_worker, (void *)sockfd);

// 接收线程函数
void *recv_worker(void *arg) {
    int sockfd = (int)arg;
    char buffer[BUFFER_SIZE];
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);

    while (1) {
        ssize_t recv_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
                                   (struct sockaddr *)&client_addr, &client_addr_len);
        if (recv_len > 0) {
            // 处理接收到的数据
            process_data(buffer, recv_len, &client_addr);
        }
    }

    return NULL;
}

零拷贝技术

使用零拷贝技术可以减少数据复制，提高性能：

// 使用sendmsg和recvmsg实现零拷贝
struct iovec iov[1];
struct msghdr msg;

// 发送
iov[0].iov_base = data;
iov[0].iov_len = data_len;

memset(&msg, 0, sizeof(msg));
msg.msg_name = dest_addr;
msg.msg_namelen = addrlen;
msg.msg_iov = iov;
msg.msg_iovlen = 1;

sendmsg(sockfd, &msg, 0);

// 接收
iov[0].iov_base = buffer;
iov[0].iov_len = buffer_size;

memset(&msg, 0, sizeof(msg));
msg.msg_name = src_addr;
msg.msg_namelen = *addrlen;
msg.msg_iov = iov;
msg.msg_iovlen = 1;

recvmsg(sockfd, &msg, 0);
*addrlen = msg.msg_namelen;

UDP的高级特性和优化技巧使其能够适应各种复杂的应用场景，从简单的点对点通信到复杂的多播流媒体系统。理解这些特性和技巧，对于开发高性能、高可靠性的UDP应用至关重要。