1
 0      7 8     15 16    23 24    31
2
+--------+--------+--------+--------+
3
|     Source      |   Destination   |
4
|      Port       |      Port       |
5
+--------+--------+--------+--------+
6
|     Length      |    Checksum     |
7
+--------+--------+--------+--------+
8
|          data octets ...          |
9
+-----------------------------------+
10
        每行 32 位，共 2 行 = 8 字节

1
// Linux 内核中的 UDP 头部定义（include/uapi/linux/udp.h）
2
struct udphdr {
3
    __be16 source;       // 源端口
4
    __be16 dest;         // 目标端口
5
    __be16 len;          // 长度
6
    __be16 check;        // 校验和
7
};
8
// 4 个 __be16 = 8 字节

1
TCP 头部（至少 20 字节）：
2
┌────────┬────────┬────────────────────┬────────┐
3
│Src Port│Dst Port│     Sequence       │Ack Num │
4
├────────┼────────┼────────────────────┼────────┤
5
│ Offset │ Flags  │      Window        │Chksum  │
6
├────────┼────────┼────────────────────┼────────┤
7
│         Urgent Pointer (可选)        │        │
8
├────────┴────────┴────────────────────┴────────┤
9
│              Options (可变长度)               │
10
└──────────────────────────────────────────────┘

1
# 用 tcpdump 观察 DNS 查询的 UDP 包
2
sudo tcpdump -i eth0 -n -vvv port 53
3

4
# 输出示例：
5
# IP 192.168.1.100.54321 > 8.8.8.8.53: UDP, length 45
6
# IP 8.8.8.8.53 > 192.168.1.100.54321: UDP, length 61
7
# 整个查询只需 2 个包，1 个 RTT

1
# TCP 服务器：每个连接占用内核内存
2
# 假设 10 万个并发连接，每个 TCB 约 4KB
3
# 总内存开销 = 100,000 × 4KB ≈ 400MB
4

5
# UDP 服务器：无连接状态
6
# 不管和多少个对端通信，内核开销几乎不变

1
# DNS 查询通常很小
2
# 请求：约 50 字节
3
# 响应：通常 < 512 字节（传统限制）
4

5
# 如果用 TCP：
6
# SYN → SYN-ACK → ACK → DNS 请求 → DNS 响应 → FIN → FIN-ACK → ACK
7
# = 8 个包，至少 2 个 RTT
8

9
# 如果用 UDP：
10
# DNS 请求 → DNS 响应
11
# = 2 个包，1 个 RTT

1
伪头部（不实际传输，仅用于计算校验和）：
2
┌──────────────────────────────────┐
3
│         Source IP Address        │  (4 字节)
4
├──────────────────────────────────┤
5
│      Destination IP Address     │  (4 字节)
6
├────────┬─────────┬───────────────┤
7
│  Zero  │Protocol │  UDP Length   │  (4 字节)
8
└────────┴─────────┴───────────────┘

1
// 计算UDP校验和的伪代码
2
uint16_t udp_checksum(struct udphdr *uh, size_t len,
3
                      uint32_t src_ip, uint32_t dst_ip) {
4
    struct pseudo_header ph;
5
    ph.src_ip = src_ip;
6
    ph.dst_ip = dst_ip;
7
    ph.zero = 0;
8
    ph.protocol = IPPROTO_UDP;  // 17
9
    ph.udp_len = htons(len);
10

11
    // 将伪头部 + UDP头 + 数据一起计算校验和
12
    return compute_checksum(&ph, sizeof(ph), uh, len);
13
}

1
# 应用层实现可靠 UDP 的核心逻辑
2
class ReliableUDP:
3
    def __init__(self):
4
        self.unacked = {}       # 未确认的数据包
5
        self.timeout = 0.5      # 重传超时（秒）
6
        self.next_seq = 0       # 下一个序列号
7
        self.recv_buffer = {}   # 接收缓冲区（处理乱序）
8

9
    def send(self, data):
10
        seq = self.next_seq
11
        self.unacked[seq] = {
12
            'data': data,
13
            'time': time.time(),
14
            'retries': 0
15
        }
16
        self.sock.sendto(self._pack(seq, data), self.addr)
17
        self.next_seq += len(data)
18

19
    def recv(self):
20
        while True:
21
            raw, addr = self.sock.recvfrom(4096)
22
            seq, payload = self._unpack(raw)
23
            self._ack(seq)  # 发送确认
24
            self.recv_buffer[seq] = payload
25
            # 按序交付
26
            if seq == self.next_expected:
27
                return self._deliver_ordered()
28

29
    def _retransmit(self):
30
        """定期检查超时并重传"""
31
        now = time.time()
32
        for seq, pkt in list(self.unacked.items()):
33
            if now - pkt['time'] > self.timeout:
34
                pkt['retries'] += 1
35
                pkt['time'] = now
36
                self.sock.sendto(self._pack(seq, pkt['data']), self.addr)