当前位置： 首页 > article >正文

Linux内核传输层UDP源码分析

article 2025/3/17 16:03:12

一、用户数据包协议（UDP）

1.UDP数据报头

        UDP 提供面向消息的不可靠传输，但没有拥塞控制功能。很多协议都使用 UDP，如用于 IP 网络传输音频和视频的实时传输协议 (Real-time Transport Protocol，RTP)，此类型容许一定的数据包丢弃。UDP 报头长 8 字节，具体内核源码如下：

2.UDP初始化操作

        定义对象udp_protocol(net_protocol对象）并使用方法inet_add_protocol()来添加它，具体源码如下：

 1. udp_protocol 结构体分析（协议注册）

static struct net_protocol udp_protocol = {
    .early_demux = udp_v4_early_demux,    // 早期解复用函数，处理初始阶段的数据包
    .early_demux_handler = udp_v4_early_demux, // 早期解复用处理器
    .handler = udp_rcv,                    // UDP 数据包接收处理函数，处理完整的 UDP 数据接收
    .err_handler = udp_err,                // 错误处理函数，处理 UDP 传输中的错误
    .no_policy = 1,                        // 标记是否忽略策略检查
    .netns_ok = 1                          // 标记是否支持网络命名空间
};
  • 作用：这是内核中 UDP 协议的注册实现。通过定义 net_protocol 类型的 udp_protocol，向内核网络子系统注册 UDP 协议的处理函数。内核通过 inet_add_protocol() 方法将其加入协议处理链，使内核能够识别和处理 UDP 数据包。

2.inet_init_net 初始化（端口范围等配置）

  • 作用：初始化网络命名空间内的 IPv4 相关参数。例如设置本地端口分配范围（ip_local_ports），限制程序动态申请端口的范围；配置 ping 套接字的用户组权限（ping_group_range），控制哪些用户组可创建 ping 套接字。

 3.发送UDP数据包udp_sendmsg(...)

        从UDP用户空间套接字中发送数据，可以使用系统调用send()、sendto()、sendmsg()和write()。这些系统调用最终都会由内核中的方法udp_sendmsg()来处理。以下是这个函数的流程图：

1. 函数参数

  • struct sock *sk：指向套接字的指针，该套接字表示当前进行 UDP 数据发送操作所使用的套接字对象，其中包含了套接字的各种状态信息和配置。
  • struct msghdr *msg：指向 msghdr 结构体的指针，这个结构体包含了要发送的数据以及目标地址等信息，例如数据缓冲区、目标地址结构体等。
  • size_t len：表示要发送的数据的长度。

2. 函数功能

udp_sendmsg 函数是 Linux 内核中用于通过 UDP 套接字发送数据的核心函数。它会对传入的消息进行一系列的检查和处理，包括验证目标地址、处理控制消息、查找路由表等操作，最终将数据封装成 UDP 数据包并发送出去。如果在发送过程中遇到错误，会返回相应的错误码；如果发送成功，则返回实际发送的数据长度。

3. 重要部分及流程讲解

3.1 基本参数检查和初始化
if (len > 0xFFFF)
    return -EMSGSIZE;

if (msg->msg_flags & MSG_OOB)
    return -EOPNOTSUPP;

getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;
  • 首先检查要发送的数据长度是否超过了 UDP 数据包的最大长度（0xFFFF），如果超过则返回 EMSGSIZE 错误。
  • 接着检查消息标志中是否包含 MSG_OOB（带外数据），由于 UDP 不支持带外数据，所以如果包含则返回 EOPNOTSUPP 错误。
  • 根据套接字是否为 UDP-Lite 类型，选择不同的数据获取函数。
3.2 处理已 corked 的套接字
fl4 = &inet->cork.fl.u.ip4;
if (up->pending) {
    lock_sock(sk);
    if (likely(up->pending)) {
        if (unlikely(up->pending != AF_INET)) {
            release_sock(sk);
            return -EINVAL;
        }
        goto do_append_data;
    }
    release_sock(sk);
}
  • 检查套接字是否已经处于 corked 状态（即有未发送的数据包）。如果是，则加锁并进一步检查状态是否正确，若不正确则返回 EINVAL 错误，若正确则跳转到 do_append_data 标签处继续处理。
3.3 获取并验证目标地址
if (usin) {
    if (msg->msg_namelen < sizeof(*usin))
        return -EINVAL;
    if (usin->sin_family != AF_INET) {
        if (usin->sin_family != AF_UNSPEC)
            return -EAFNOSUPPORT;
    }

    daddr = usin->sin_addr.s_addr;
    dport = usin->sin_port;
    if (dport == 0)
        return -EINVAL;
} else {
    if (sk->sk_state != TCP_ESTABLISHED)
        return -EDESTADDRREQ;
    daddr = inet->inet_daddr;
    dport = inet->inet_dport;
    connected = 1;
}
  • 如果 msg 中包含目标地址信息，则检查地址长度和地址族是否正确，获取目标 IP 地址和端口号，并验证端口号是否有效。
  • 如果 msg 中不包含目标地址信息，则检查套接字是否已经连接，如果未连接则返回 EDESTADDRREQ 错误，否则使用套接字中保存的目标地址和端口号，并标记为已连接。
3.4 处理控制消息
if (msg->msg_controllen) {
    err = udp_cmsg_send(sk, msg, &ipc.gso_size);
    if (err > 0)
        err = ip_cmsg_send(sk, msg, &ipc, sk->sk_family == AF_INET6);
    if (unlikely(err < 0)) {
        kfree(ipc.opt);
        return err;
    }
    if (ipc.opt)
        free = 1;
    connected = 0;
}
3.5 查找路由表
if (connected)
    rt = (struct rtable *)sk_dst_check(sk, 0);

if (!rt) {
    struct net *net = sock_net(sk);
    __u8 flow_flags = inet_sk_flowi_flags(sk);

    fl4 = &fl4_stack;

    flowi4_init_output(fl4, ipc.oif, ipc.sockc.mark, tos,
                       RT_SCOPE_UNIVERSE, sk->sk_protocol,
                       flow_flags,
                       faddr, saddr, dport, inet->inet_sport,
                       sk->sk_uid);

    security_sk_classify_flow(sk, flowi4_to_flowi(fl4));
    rt = ip_route_output_flow(net, fl4, sk);
    if (IS_ERR(rt)) {
        err = PTR_ERR(rt);
        rt = NULL;
        if (err == -ENETUNREACH)
            IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
        goto out;
    }

    err = -EACCES;
    if ((rt->rt_flags & RTCF_BROADCAST) &&
        !sock_flag(sk, SOCK_BROADCAST))
        goto out;
    if (connected)
        sk_dst_set(sk, dst_clone(&rt->dst));
}
  • 如果套接字已经连接，则检查缓存的路由信息是否可用。
  • 如果没有可用的路由信息，则初始化 flowi4 结构体，进行安全分类，并调用 ip_route_output_flow 函数查找路由表。如果查找失败，则根据错误码进行相应处理，如增加统计信息并跳转到 out 标签处。
  • 如果路由表中包含广播标志，但套接字不允许广播，则返回 EACCES 错误。
3.6 发送数据
if (!corkreq) {
    struct inet_cork cork;

    skb = ip_make_skb(sk, fl4, getfrag, msg, ulen,
                      sizeof(struct udphdr), &ipc, &rt,
                      &cork, msg->msg_flags);
    err = PTR_ERR(skb);
    if (!IS_ERR_OR_NULL(skb))
        err = udp_send_skb(skb, fl4, &cork);
    goto out;
}

lock_sock(sk);
if (unlikely(up->pending)) {
    release_sock(sk);
    net_dbg_ratelimited("socket already corked\n");
    err = -EINVAL;
    goto out;
}
fl4 = &inet->cork.fl.u.ip4;
fl4->daddr = daddr;
fl4->saddr = saddr;
fl4->fl4_dport = dport;
fl4->fl4_sport = inet->inet_sport;
up->pending = AF_INET;

do_append_data:
up->len += ulen;
err = ip_append_data(sk, fl4, getfrag, msg, ulen,
                     sizeof(struct udphdr), &ipc, &rt,
                     corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
if (err)
    udp_flush_pending_frames(sk);
else if (!corkreq)
    err = udp_push_pending_frames(sk);
else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
    up->pending = 0;
release_sock(sk);
  • 如果不需要 cork 操作（即 corkreq 为 false），则调用 ip_make_skb 函数创建一个 skb（套接字缓冲区），并调用 udp_send_skb 函数发送数据。
  • 如果需要 cork 操作，则加锁并检查套接字状态，更新相关信息，然后调用 ip_append_data 函数将数据追加到缓冲区中。如果追加过程中出现错误，则调用 udp_flush_pending_frames 函数清空缓冲区；如果不需要 cork 操作，则调用 udp_push_pending_frames 函数将缓冲区中的数据发送出去。
3.7 清理资源并返回结果
out:
ip_rt_put(rt);
out_free:
if (free)
    kfree(ipc.opt);
if (!err)
    return len;
if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
    UDP_INC_STATS(sock_net(sk),
                  UDP_MIB_SNDBUFERRORS, is_udplite);
}
return err;
  • 释放路由表资源和控制消息相关的内存。
  • 如果没有错误发生，则返回实际发送的数据长度；如果出现错误，则根据错误码进行相应的统计更新并返回错误码。
如果  msg 中包含控制消息，则调用  udp_cmsg_send 和  ip_cmsg_send 函数处理这些控制消息。如果处理过程中出现错误，则释放相关资源并返回错误码。

4.接收来自网络层的UDP数据包udp_rcv(...)

        方法udp_rcv()是负责接收来自网络层的UDP数据包的主要处理程序，函数流程如下：

1. 函数参数和功能

函数参数
  • struct sk_buff *skb：指向套接字缓冲区的指针，其中包含接收到的 UDP 数据包。
  • struct udp_table *udptable：指向 UDP 表的指针，该表用于存储 UDP 套接字的相关信息。
  • int proto：协议类型，通常为 IPPROTO_UDP。
函数功能

udp_rcv 函数是一个简单的包装函数，它直接调用 __udp4_lib_rcv 函数来处理接收到的 UDP 数据包。__udp4_lib_rcv 函数是处理 UDP 数据包接收的核心函数，它会对数据包进行一系列的验证和处理，包括检查数据包长度、校验和，查找对应的套接字，将数据包传递给相应的套接字进行处理，或者在找不到合适套接字时发送 ICMP 错误消息。

2. 重要部分及流程讲解

2.1 基本参数检查和初始化
if (!pskb_may_pull(skb, sizeof(struct udphdr)))
    goto drop;		/* No space for header. */

uh   = udp_hdr(skb);
ulen = ntohs(uh->len);
saddr = ip_hdr(skb)->saddr;
daddr = ip_hdr(skb)->daddr;
  • 首先检查套接字缓冲区中是否有足够的空间来存储 UDP 头部，如果没有则跳转到 drop 标签处丢弃数据包。
  • 提取 UDP 头部信息，包括 UDP 数据包长度 ulen，源 IP 地址 saddr 和目的 IP 地址 daddr。
2.2 数据包长度验证
if (ulen > skb->len)
    goto short_packet;

if (proto == IPPROTO_UDP) {
    /* UDP validates ulen. */
    if (ulen < sizeof(*uh) || pskb_trim_rcsum(skb, ulen))
        goto short_packet;
    uh = udp_hdr(skb);
}
  • 检查 UDP 头部中记录的数据包长度 ulen 是否超过了实际接收到的数据包长度 skb->len，如果超过则跳转到 short_packet 标签处处理。
  • 如果协议类型为 IPPROTO_UDP，还需要检查 ulen 是否小于 UDP 头部长度，或者调用 pskb_trim_rcsum 函数对数据包进行裁剪和校验和更新，如果出现问题则跳转到 short_packet 标签处。
2.3 校验和初始化
if (udp4_csum_init(skb, uh, proto))
    goto csum_error;

调用 udp4_csum_init 函数对 UDP 数据包的校验和进行初始化，如果初始化失败则跳转到 csum_error 标签处处理。

2.4 查找套接字并处理
sk = skb_steal_sock(skb);
if (sk) {
    struct dst_entry *dst = skb_dst(skb);
    int ret;

    if (unlikely(sk->sk_rx_dst != dst))
        udp_sk_rx_dst_set(sk, dst);

    ret = udp_unicast_rcv_skb(sk, skb, uh);
    sock_put(sk);
    return ret;
}
  • 尝试从套接字缓冲区中获取关联的套接字 sk。
  • 如果获取到了套接字，检查接收目标地址是否与套接字中的记录一致，如果不一致则更新。
  • 调用 udp_unicast_rcv_skb 函数将数据包传递给该套接字进行处理，并返回处理结果。
2.5 处理广播或多播数据包
if (rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST))
    return __udp4_lib_mcast_deliver(net, skb, uh,
                    saddr, daddr, udptable, proto);

如果路由表项中包含广播或多播标志，则调用 __udp4_lib_mcast_deliver 函数处理广播或多播数据包。

2.6 再次查找套接字
sk = __udp4_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
if (sk)
    return udp_unicast_rcv_skb(sk, skb, uh);

如果之前没有找到关联的套接字，再次调用 __udp4_lib_lookup_skb 函数根据源端口和目的端口在 UDP 表中查找合适的套接字。如果找到则将数据包传递给该套接字进行处理并返回结果，

这个过程通常包含以下步骤：

  • 把接收到的数据添加到套接字的接收缓冲区。
  • 若应用程序正在阻塞等待数据，就会唤醒该应用程序，让其从接收缓冲区读取数据。
  • 若应用程序采用的是非阻塞模式，就会在后续的轮询或事件通知中得知有新数据到达。
2.7 策略检查和校验和检查
if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
    goto drop;
nf_reset_ct(skb);

/* No socket. Drop packet silently, if checksum is wrong */
if (udp_lib_checksum_complete(skb))
    goto csum_error;
  • 重置连接跟踪信息。
  • 调用 udp_lib_checksum_complete 函数检查 UDP 数据包的校验和，如果校验和错误则跳转到 csum_error 标签处处理。
2.8 发送 ICMP 错误消息
__UDP_INC_STATS(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);

/*
 * Hmm.  We got an UDP packet to a port to which we
 * don't wanna listen.  Ignore it.
 */
kfree_skb(skb);
return 0;

如果没有找到合适的套接字，增加相应的统计信息，调用 icmp_send 函数发送 ICMP 目的不可达（端口不可达）消息，然后释放套接字缓冲区并返回 0。

2.9 错误处理
short_packet:
    net_dbg_ratelimited("UDP%s: short packet: From %pI4:%u %d/%d to %pI4:%u\n",
                        proto == IPPROTO_UDPLITE ? "Lite" : "",
                        &saddr, ntohs(uh->source),
                        ulen, skb->len,
                        &daddr, ntohs(uh->dest));
    goto drop;

csum_error:
    /*
     * RFC1122: OK.  Discards the bad packet silently (as far as
     * the network is concerned, anyway) as per 4.1.3.4 (MUST).
     */
    net_dbg_ratelimited("UDP%s: bad checksum. From %pI4:%u to %pI4:%u ulen %d\n",
                        proto == IPPROTO_UDPLITE ? "Lite" : "",
                        &saddr, ntohs(uh->source), &daddr, ntohs(uh->dest),
                        ulen);
    __UDP_INC_STATS(net, UDP_MIB_CSUMERRORS, proto == IPPROTO_UDPLITE);
drop:
    __UDP_INC_STATS(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
    kfree_skb(skb);
    return 0;
  • short_packet 标签处：记录数据包长度过短的调试信息，然后跳转到 drop 标签处。
  • csum_error 标签处：记录校验和错误的调试信息，增加校验和错误的统计信息，然后跳转到 drop 标签处。
  • drop 标签处：增加接收错误的统计信息，释放套接字缓冲区并返回 0。
调用  xfrm4_policy_check 函数进行安全策略检查，如果检查不通过则跳转到  drop 标签处丢弃数据包。

5.UDP使用流程 

1. 用户层调用（sendto）

  • 用户通过 socket () 创建 UDP 套接字，调用 sendto () 发送数据报
  • 参数包含目标 IP (47.95.193.211)、端口 (默认可能未指定，需填充)
  • 内核进入 inet_sendmsg () 处理，分配 skb_buff（创建位置：传输层）

2. 传输层处理（UDP 层）

  • 创建 sk_buff 数据结构（skb->dev = 网络设备指针）
  • 填充 UDP 头（源端口 8888，目标端口待确认）
  • 计算校验和（可选，由 net.core.udp_checksum 内核参数控制）
  • skb->protocol = htons (ETH_P_IP)，标识上层协议

3. 网络层处理（IP 层）

  • 调用 ip_queue_xmit () 进行路由查找
  • 路由表查询：
    • 使用 FIB 表（fib_rules）查找最佳路由
    • 确定输出设备（eth0/wlan0 等）
    • 下一跳地址（可能是网关地址，若目标不在同一子网）
  • 填充 IP 头：
    • 源 IP (192.168.186.138)，目标 IP (47.95.193.211)
    • TTL、协议号 (17)、校验和
  • 检查是否需要分片（根据 MTU）

4. 链路层处理

  • 调用 dev_queue_xmit () 进入链路层
  • ARP 表查询：
    • 使用 neigh_table 结构查找 arp_cache
    • 若下一跳是网关，查询网关 MAC
    • 若目标在同一子网，直接查目标 MAC
    • 若 ARP 缓存缺失，触发 ARP 请求
  • 填充链路层头（以太网为例）：
    • 源 MAC（本地网卡 MAC）
    • 目标 MAC（下一跳或目标 MAC）
    • 类型字段 0x0800（IP 协议）

5. 物理层传输

  • sk_buff 通过 net_device_ops->ndo_start_xmit () 发送
  • 物理层将二进制数据转换为电信号 / 光信号传输

接收流程简要说明：

  1. 物理层接收信号并转为二进制数据
  2. 链路层剥离帧头，检查 CRC 校验
  3. IP 层校验和验证，路由表查找输入接口
  4. UDP 层校验和验证，端口号匹配
  5. 用户层通过 recvfrom () 接收数据

关键数据结构说明：

  • sk_buff：贯穿各层，包含协议头、数据负载、设备指针等
  • fib_rules：路由规则表，用于确定输出路径
  • arp_cache：基于 neigh_table 的邻居缓存，存储 IP-MAC 映射
  • net_device：网络设备结构体，包含发送 / 接收函数指针

http://www.kler.cn/a/588552.html

相关文章：

  • 日志、类加载器、XML（配置文件）
  • 【HarmonyOS NEXT】实现文字环绕动态文本效果
  • JS基础部分
  • DeepSeek在学术写作选择研究方向的2个核心提示词
  • pip install和conda install的区别
  • C# --- LINQ
  • 没有公网服务器的情况下，建立反弹 Shell
  • 网络编程、URI和URL的区别、TCP/IP协议、IP和端口、URLConnection
  • LLM(3)： Transformer 架构
  • 数据结构-树（详解）
  • 力扣Hot100——35.搜索插入的位置（二分查找）
  • [C语言]数据在内存中的存储
  • ai数字人系统系统saas源码 一站式开发目录
  • 前端 git规范-不同软件（GitHub、Sourcetree、WebStorm）、命令行合并方式下增加 --no-ff的方法
  • 【Vue】上传PDF功能
  • 鸿蒙路由 HMrouter 配置及使用一
  • Android笔记：Android平台下SVG格式的解析与实践
  • PyTorch使用-张量数值计算
  • 每日Attention学习27——Patch-based Graph Reasoning
  • 【从零开始学习计算机科学】软件工程（六）软件质量