UDP协议源码分析

Posted 2021-04-04 Linux内核那些事

UDP协议是 User Datagram Protocol 的简称， 中文名是用户数据报协议，是OSI（Open System Interconnection，开放式系统互联） 参考模型中一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务，位于 TCP/IP协议 模型的 传输层，如下图：

也就是说 UDP协议 是建立中 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; }

上面的代码主要完成以下几个工作：

我们继续分析 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_build_xmit() 函数是 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_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协议 的接收工作就此完毕。