UDP协议源码分析（基于 Linux-2.4.0已更新）
UDP协议源码分析
UDP协议 是 User Datagram Protocol 的简称， 中文名是用户数据报协议，是 OSI（Open System Interconnection，开放式系统互联） 参考模型中一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务，位于 TCP/IP协议 模型的 传输层，如下图：
也就是说 UDP协议 是建立中 IP协议（网络层）之上的，IP协议 用于区分网络上不同的主机（IP协议源码分析），而 UDP协议 用于区分同一台主机上不同的进程发送（接收）的网络数据，如下图所示：
从上图可以看出，UDP协议 通过 端口号 来区分不同进程的数据包。
UDP协议头
下面我们来看看 UDP协议 的协议头部，如下图所示：
从上图可知，UDP头部 由四个字段组成：源端口、目标端口、数据包长度 和 校验和。
源端口 用于指示本机的进程，而 目标端口 用于指示远端的进程。数据包长度 表示这个 UDP 数据包总长度（包括UDP头部和 数据长度），而 校验和 用于校验数据包在传输的过程中是否损坏了。
下面我们看看 UDP头部 在内核中的表示方式，如下代码：
struct udphdr {
__u16 source; // 源端口
__u16 dest; // 目标端口
__u16 len; // 数据包长度
__u16 check; // 校验和
};
可以看出，udphdr 结构的字段与 UDP头部 结构图中的字段一一对应。最后，我们来看看 UDP头部 在数据包的具体位置，如下图：
下面我们主要通过 UDP 数据包的发送和接收两个过程来分析 UDP 在内核中的实现原理。
UDP数据包发送
数据的发送是由应用层调用 send() 或者 write() 系统调用，将数据传递到传输层协议处理，如下图：
从上图可以看出，用户态 的应用程序调用 send() 系统调用时会触发调用 内核态 的 sys_send() 内核函数，而 sys_send() 最终会调用 inet_sendmsg() 函数发送数据。
inet_sendmsg() 函数会根据用户使用的传输层协议选择不同的数据发送接口，比如 UDP 协议就会使用 udp_sendmsg() 函数发送数据。
我们来分析一下 UDP 协议的发送接口 udp_sendmsg() 函数的实现，代码如下（由于 udp_sendmsg() 函数的实现比较复杂，所以我们分段分析）：
int udp_sendmsg(struct sock *sk, struct msghdr *msg, int len)
{
int ulen = len + sizeof(struct udphdr);
struct ipcm_cookie ipc;
struct udpfakehdr ufh;
struct rtable *rt = NULL;
int free = 0;
int connected = 0;
u32 daddr;
u8 tos;
int err;
udp_sendmsg() 函数的参数含义如下：
sk：Socket 对象。msg：要发送的数据实体，其类型为msghdr结构。len：要发送的数据长度。
上面的代码主要定义了一些局部变量，如：
-
ulen变量就是要发送的数据总长度（UDP头部长度和数据长度之和）。 -
rt变量表示数据传输的路由信息，其类型为rtable结构。 -
ufh变量是调用 IP 层ip_build_xmit()函数时的上下文，主要用于构建UDP协议头部，其类型为udpfakehdr结构。
我们接口分析 udp_sendmsg() 函数：
// 是否提供了接收数据的目标IP地址和端口
if (msg->msg_name) {
// 接收数据的目标IP地址和端口
struct sockaddr_in *usin = (struct sockaddr_in*)msg->msg_name;
if (msg->msg_namelen < sizeof(*usin))
return -EINVAL;
if (usin->sin_family != AF_INET) {
if (usin->sin_family != AF_UNSPEC)
return -EINVAL;
}
// 设置接收数据的目标IP地址和端口
ufh.daddr = usin->sin_addr.s_addr;
ufh.uh.dest = usin->sin_port;
if (ufh.uh.dest == 0)
return -EINVAL;
} else {
if (sk->state != TCP_ESTABLISHED)
return -ENOTCONN;
ufh.daddr = sk->daddr; // 使用绑定Socket的IP地址
ufh.uh.dest = sk->dport; // 使用绑定Socket的端口
connected = 1;
}
上面的代码主要完成以下几个工作：
- 如果用户发送数据时提供了目标 IP 地址和端口，就把用户提供的目标 IP 地址和端口复制到
ufh变量中。 - 否则就把绑定到 Socket 对象的目标 IP 地址和端口复制到
ufh变量中，并且设置connected变量为 1。
我们继续分析 udp_sendmsg() 函数，代码如下：
if (connected)
rt = (struct rtable*)sk_dst_check(sk, 0); // 获取路由信息对象缓存
if (rt == NULL) { // 如果路由信息对象还没被缓存
// 调用 ip_route_output() 函数获取路由信息对象
err = ip_route_output(&rt, daddr, ufh.saddr, tos, ipc.oif);
if (err)
goto out;
err = -EACCES;
if (rt->rt_flags & RTCF_BROADCAST && !sk->broadcast)
goto out;
if (connected)
sk_dst_set(sk, dst_clone(&rt->u.dst)); // 设置路由信息对象缓存
}
上面的代码比较简单，首先调用 sk_dst_check() 查看 路由信息对象 是否被缓存，如果已经缓存，那么直接使用此 路由信息对象。否则调用 ip_route_output() 函数获取 路由信息对象，并且调用 sk_dst_set() 设置 路由信息对象 缓存。
路由信息对象 指明数据在传送过程的 下一跳 主机的信息（通常为网关），有了 下一跳 主机的信息，就可以把数据转发给 下一跳 主机，然后由 下一跳 主机继续完成发送工作。
我们继续分析 udp_sendmsg() 函数，代码如下：
ufh.saddr = rt->rt_src; // 设置源IP地址
if (!ipc.addr) // 如果没有提供目标IP地址，使用路由信息的目标IP地址
ufh.daddr = ipc.addr = rt->rt_dst;
ufh.uh.len = htons(ulen);
ufh.uh.check = 0;
ufh.iov = msg->msg_iov;
ufh.wcheck = 0;
// 构建MAC头部、IP头部和UDP头部并且下发给IP协议层
err = ip_build_xmit(sk, (sk->no_check == UDP_CSUM_NOXMIT
? udp_getfrag_nosum
: udp_getfrag),
&ufh, ulen, &ipc, rt, msg->msg_flags);
out:
ip_rt_put(rt);
...
return err;
}
上面的代码主要把 路由信息对象 的源IP地址复制到 ufh 变量中，然后调用 ip_build_xmit() 函数完成数据发送的后续工作。ip_build_xmit() 函数的第一个参数用于复制 UDP头部 和负载数据到数据包的函数指针，IP 层通过调用此函数把 UDP头部 和负载数据复制到数据包中。
ip_build_xmit() 函数是 IP 协议层的实现，这里就不作说明，可以参考此文章：IP协议源码分析。
总的来说，udp_sendmsg() 函数的主要工作就是为要发送的数据包构建 UDP头部，然后把数据包交由 IP 层完成接下来的发送操作，所以 UDP协议 的发送过程比较简单。
UDP数据包接收
当网卡设备接收到数据包后，会交由内核协议栈处理。内核协议栈对数据包的处理是由下至上，如下图所示：
也就是说，物理层处理完数据包后会交由链路层处理，而链路层处理完交由网络层处理，以此类推。
所以当网络层（IP协议）处理完数据包后，会交由传输层处理，在本文中介绍的传输层协议是 UDP协议，所以这里主要介绍的是 UDP协议 对数据包的处理过程。
当 IP 协议层处理完数据包后，如果 IP 头部的上层协议字段（protocol 字段）指明的是 UDP协议，那么就会调用 udp_rcv() 函数处理数据包。下面我们来分析一下 udp_rcv() 函数的实现，代码如下：
int udp_rcv(struct sk_buff *skb, unsigned short len)
{
struct sock *sk;
struct udphdr *uh;
unsigned short ulen;
struct rtable *rt = (struct rtable*)skb->dst; // 路由信息对象
u32 saddr = skb->nh.iph->saddr; // 远端IP地址(源IP地址)
u32 daddr = skb->nh.iph->daddr; // 本地IP地址(目标IP地址)
uh = skb->h.uh; // UDP头部
...
// 根据目标端口获取对用的 Socket 对象
sk = udp_v4_lookup(saddr, uh->source, daddr, uh->dest, skb->dev->ifindex);
if (sk != NULL) {
udp_queue_rcv_skb(sk, skb); // 把数据包添加到Socket对象的receive_queue队列中
sock_put(sk);
return 0;
}
...
}
udp_rcv() 函数主要完成两个工作：
- 调用
udp_v4_lookup()函数获取目标端口对应的Socket对象。 - 调用
udp_queue_rcv_skb()函数把数据包添加到Socket对象的receive_queue队列中。
UDP协议 使用了一个名为 udp_hash 的哈希表来保存所有绑定了端口的 Socket 对象，当应用程序调用 bind() 系统调用为 Socket 对象绑定端口时，就会将此 Socket 对象添加到 udp_hash 哈希表中。
而 udp_v4_lookup() 函数就是根据目标端口从 udp_hash 哈希表中获取对应的 Socket 对象，udp_v4_lookup() 函数实现如下：
__inline__ struct sock *
udp_v4_lookup(u32 saddr, u16 sport, u32 daddr, u16 dport, int dif)
{
struct sock *sk;
read_lock(&udp_hash_lock); // 为udp_hash哈希表上锁
sk = udp_v4_lookup_longway(saddr, sport, daddr, dport, dif);
if (sk)
sock_hold(sk);
read_unlock(&udp_hash_lock);
return sk;
}
udp_v4_lookup() 函数首先为 udp_hash 哈希表上锁，然后调用 udp_v4_lookup_longway() 函数从 udp_hash 哈希表中获取对应目标端口的 Socket 对象，udp_v4_lookup_longway() 函数的实现如下：
struct sock *
udp_v4_lookup_longway(u32 saddr, // 源IP地址(远端IP地址)
u16 sport, // 源端口(远端端口)
u32 daddr, // 目标IP地址(本地IP地址)
u16 dport, // 目标端口(本地端口)
int dif)
{
struct sock *sk, *result = NULL;
unsigned short hnum = ntohs(dport);
int badness = -1;
// 根据目标端口从 udp_hash 哈希表中获取对应的 Socket 对象
for (sk = udp_hash[hnum&(UDP_HTABLE_SIZE - 1)]; sk != NULL; sk = sk->next) {
if (sk->num == hnum) { // 对比目标端口是否匹配
int score = 0;
if (sk->rcv_saddr) { // 如果Socket设置了固定的本地接收IP
if(sk->rcv_saddr != daddr) // 对比目标IP地址是否匹配
continue;
score++;
}
if (sk->daddr) { // 如果Socket设置了固定的远端接收IP
if(sk->daddr != saddr) // 对比源IP地址是否匹配
continue;
score++;
}
if (sk->dport) { // 如果Socket设置了固定的远端接收端口
if(sk->dport != sport) // 对比源端口是否匹配
continue;
score++;
}
if (sk->bound_dev_if) { // 如果Socket设置了固定的接收网络设备
if(sk->bound_dev_if != dif) // 对比接收设备是否匹配
continue;
score++;
}
if (score == 4) { // 完美匹配, 那么直接返回即可
result = sk;
break;
} else if(score > badness) { // 否则使用分数最高的Socket对象
result = sk;
badness = score;
}
}
}
return result;
}
udp_v4_lookup_longway() 函数的主要逻辑就是根据目标端口从 udp_hash 哈希表中获取对应的 Socket 对象。
由于同一个端口有可能绑定了多个 Socket 对象，所以 udp_v4_lookup_longway() 函数查找 Socket 对象时使用了最优匹配，也就是说除了匹配目标端口外，还可能会匹配源 IP 地址、源端口和目标 IP 地址等。
找到目标端口对应的 Socket 对象后，就可以调用 udp_queue_rcv_skb() 函数把数据包添加到 Socket 对象的 receive_queue 队列中，udp_queue_rcv_skb() 函数实现如下：
static int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
{
...
if (sock_queue_rcv_skb(sk, skb) < 0) {
...
return -1;
}
return 0;
}
从上面代码可以看出，udp_queue_rcv_skb() 函数最终会调用 sock_queue_rcv_skb() 函数完成任务，所以我们来分析一下 sock_queue_rcv_skb() 函数的实现，代码如下：
static inline int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
{
...
// 把数据包添加到Socket对象的receive_queue队列
skb_queue_tail(&sk->receive_queue, skb);
if (!sk->dead)
sk->data_ready(sk, skb->len); // 唤醒等待Socket对象就绪的进程
return 0;
}
sock_queue_rcv_skb() 通过调用 skb_queue_tail() 函数把 skb 数据包添加到 Socket 对象的 receive_queue 队列中，并且唤醒等待 Socket 对象就绪的进程。
当把数据包添加到 Socket 对象的 receive_queue 队列后，UDP协议 的接收工作就此完毕。
