第12周：IP 层与路由子系统

字数统计: 2.3k字   |   阅读时长≈ 11分

第12周：IP 层与路由子系统

目标：理解 IP 分片重组、路由查找（FIB）机制，能基于源 IP 选择路由。

1. IP 层核心数据结构

1.1 iphdr（IP 头）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
struct iphdr {
#if defined(__LITTLE_ENDIAN_BITFIELD)
    __u8    ihl:4,
            version:4;
#elif defined(__BIG_ENDIAN_BITFIELD)
    __u8    version:4,
            ihl:4;
#else
#error "Please fix <asm/byteorder.h>"
#endif
    __u8    tos;                // 服务类型
    __be16  tot_len;            // 总长度（头+数据）
    __be16  id;                 // 分片 ID
    __be16  frag_off;           // 分片偏移 + 标志
    __u8    ttl;                // TTL
    __u8    protocol;           // 上层协议
    __sum16 check;             // 校验和
    __be32  saddr;              // 源 IP
    __be32  daddr;              // 目的 IP
    // ihl * 4 字节之后的才是数据
};

// frag_off 字段分解：
// 0-12 bit: 分片偏移（以 8 字节为单位）
// 13 bit:   保留
// 14 bit:   DF (Don't Fragment)
// 15 bit:   MF (More Fragments)

1.2 标志位操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <linux/ip.h>

// 分片标志
#define IP_OFFSET 0x1FFF    // 分片偏移掩码（13 bit）
#define IP_MF     0x2000    // More Fragments
#define IP_DF     0x4000    // Don't Fragment

// 操作示例
u16 frag_off = iph->frag_off;

// 获取偏移（以 8 字节为单位）
u16 offset = ntohs(frag_off) & IP_OFFSET;

// 检查是否为最后一个分片
bool is_last = !(ntohs(frag_off) & IP_MF);

// 检查是否允许分片
bool can_fragment = !(ntohs(frag_off) & IP_DF);

// 设置 DF 标志
iph->frag_off |= htons(IP_DF);

2. IP 分片与重组

2.1 为什么需要分片？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
MTU（最大传输单元）：
  Ethernet: 1500 字节
  PPPoE:   1492 字节
  VPN:     通常 1400-1450

IP 数据包最大 = MTU - IP头(20) = 1480 字节

如果应用层要发一个 4000 字节的 UDP 包：
  → 必须分片为多个 IP 包
  → 分片 1: 1480 数据
  → 分片 2: 1480 数据
  → 分片 3: 1040 数据 (MF=0)

接收端重组为原始 4000 字节包

2.2 分片过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 内核中的分片逻辑（简化）

int ip_fragment(struct net *net, struct sk_buff *skb,
                int (*output)(struct net *, struct sock *, struct sk_buff *)) {
    struct iphdr *iph = ip_hdr(skb);
    u32 mtu = ip_dst_mtu(skb_dst(skb));  // 下一跳的 MTU

    // 计算可用数据空间（MTU - IP头 - 扩展头）
    u32 max_plen = mtu - ip_hdrlen(skb) - l3_hdr_len;

    if (iph->tot_len <= htons(mtu)) {
        // 不需要分片
        return output(net, skb->sk, skb);
    }

    // 需要分片，按 8 字节对齐
    u32 frag_maxlen = max_plen & ~7;  // 向下对齐到 8

    // 分片为 N 个包
    for (u32 offset = 0; offset < ntohs(iph->tot_len); offset += frag_maxlen) {
        struct sk_buff *frag = alloc_skb(mtu + LL_MAX_HEADER, GFP_ATOMIC);
        // ... 复制数据、设置标志
        // MF = 还有后续分片
        // 最后一个分片 MF = 0
    }

    kfree_skb(skb);  // 释放原始包
    return 0;
}

2.3 重组过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 重组在 ip_defrag() 中完成
struct ipq {  // 重组队列条目
    struct iphdr    *iph;        // 第一个分片的 IP 头
    struct sk_buff  *head;       // 分片链表头
    struct sk_buff  *tail;       // 分片链表尾
    __be32           saddr;      // 源 IP
    __be32           daddr;      // 目的 IP
    __u16            id;         // 分片 ID
    atomic_t         count;      // 引用计数
    unsigned int     len;        // 已接收总长度
    unsigned int     meat;       // 期望总长度
    struct timer_list timer;     // 超时计时器（60 秒）
};

// 重组过程：
// 1. 收到分片 → 查找或创建 ipq 条目
// 2. 按偏移插入分片链表
// 3. 检测是否所有分片都到齐（offset + len == tot_len）
// 4. 到齐后：skb_queue_walk 合并所有分片
// 5. 交付给上层

3. 路由子系统（FIB）

3.1 路由表结构

1
2
3
4
5
6
7
8
9
10
11
12
路由表（Forwarding Information Base）：
  每条路由记录：
    目的网络    掩码        下一跳/出接口   度量
    0.0.0.0/0   0.0.0.0    192.168.1.1    默认路由
    192.168.1.0/24 255.255.255.0  直接连接   eth0
    10.0.0.0/8  255.0.0.0   192.168.1.254

路由查找：
  输入: 目的 IP 地址
  1. 查找最长匹配前缀（LPM）
  2. 多条匹配时选优先级最高的
  3. 返回路由条目（nexthop + 出接口）

3.2 路由查找流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// 简化版路由查找

int ip_route_input_slow(struct sk_buff *skb, __be32 daddr,
                        __be32 saddr, u8 tos) {
    struct fib_table *fib_table;
    struct fib_result res;
    int err;

    // 1. 查找路由表（默认表 + 策略路由表）
    fib_table = fib_get_table(&init_net, RT_TABLE_MAIN);

    // 2. FIB 查找（最长前缀匹配）
    err = fib_table_lookup(fib_table, daddr, saddr, tos, 0, &res);

    if (err) {
        // 没有匹配的路由
        return -ENETUNREACH;
    }

    // 3. 填充路由结果
    // res.prefix = 匹配的网络前缀
    // res.prefixlen = 前缀长度
    // res.fi = 路由条目
    // res.type = RTN_UNICAST / RTN_LOCAL / RTN_BROADCAST

    // 4. 设置 socket 缓冲区路由
    skb_dst_set(skb, &res->dst);

    return 0;
}

// fib_result 结构
struct fib_result {
    __be32          prefix;       // 网络前缀
    unsigned char   prefixlen;    // 前缀长度
    unsigned char   nh_sel;       // nexthop 选择
    unsigned char   type;         // RTN_UNICAST/LOCAL/BROADCAST/ANYCAST
    unsigned char   scope;        // RT_SCOPE_UNIVERSE/LINK/HOST
    unsigned char   tclassid;     // 流量控制类
    struct fib_info *fi;          // 路由信息
    struct fib_table *table;      // 所属表
};

3.3 策略路由（Policy Routing）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
默认路由：所有包按一个路由表处理

策略路由：多个路由表，根据条件选择：
  1. 源 IP → 不同的路由表
  2. TOS/DSCP → 不同的路由表
  3. fwmark → 不同的路由表

Linux 路由表编号：
  RT_TABLE_UNSPEC  = 0    // 未指定
  RT_TABLE_DEFAULT = 253  // 默认表
  RT_TABLE_MAIN    = 254  // 主表
  RT_TABLE_LOCAL   = 255  // 本地表

可用自定义表：1-252
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# === 策略路由配置 ===

# 1. 添加自定义路由表（/etc/iproute2/rt_tables）
# 200 wan1
# 201 wan2

# 2. 添加路由
sudo ip route add 10.0.0.0/8 via 192.168.1.1 table wan1
sudo ip route add 172.16.0.0/12 via 10.0.0.1 table wan2

# 3. 基于源 IP 选择路由表
sudo ip rule add from 192.168.1.0/24 table wan1
sudo ip rule add from 10.0.0.0/8 table wan2

# 4. 基于 fwmark 选择
sudo ip rule add fwmark 1 table wan1
sudo ip rule add fwmark 2 table wan2

# 5. 查看规则
sudo ip rule show
# 0:  from all lookup local
# 32766:  from all lookup main
# 32767:  from all lookup default

# 查看路由表
sudo ip route show table wan1
sudo ip route show table all

3.4 内核模块读取路由

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <linux/netdevice.h>
#include <linux/in_route.h>
#include <net/route.h>

// 查找路由
static struct rtable *lookup_route(__be32 daddr) {
    struct rtable *rt;
    struct flowi4 fl4;

    memset(&fl4, 0, sizeof(fl4));
    fl4.daddr = daddr;
    fl4.flowi4_oif = l3mdev_fib_oif;
    fl4.flowi4_mark = 0;

    rt = ip_route_output_key(&init_net, &fl4);
    if (IS_ERR(rt)) {
        printk(KERN_ERR "No route to %pI4\n", &daddr);
        return NULL;
    }

    printk(KERN_INFO "Route: %pI4 -> dev %s, via %pI4\n",
           &daddr, rt->dst.dev->name,
           &rt->rt_gateway);
    return rt;
}

4. 实践：基于源 IP 的路由选择

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
// src_routing.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netfilter.h>
#include <linux/netfilter_ipv4.h>
#include <linux/ip.h>
#include <linux/route.h>
#include <linux/in_route.h>

// 路由表策略：
// 192.168.1.0/24 → 使用 eth0
// 10.0.0.0/8 → 使用 eth1
// 其他 → 默认 eth0

#define ETH0_NET 0xC0A80100  // 192.168.1.0
#define ETH0_MASK 0xFFFFFF00
#define ETH1_NET 0x0A000000  // 10.0.0.0
#define ETH1_MASK 0xFF000000

static unsigned int src_routing_hook(void *priv,
                                     struct sk_buff *skb,
                                     const struct nf_hook_state *state) {
    struct iphdr *iph;
    struct rtable *rt;
    struct flowi4 fl4;
    struct net_device *dev;

    if (!skb) return NF_ACCEPT;
    iph = ip_hdr(skb);
    if (!iph) return NF_ACCEPT;

    // 只处理数据包（非本地生成）
    if (state->hook != NF_INET_PRE_ROUTING)
        return NF_ACCEPT;

    // 基于源 IP 选择输出接口
    __be32 saddr = iph->saddr;

    if ((saddr & htonl(ETH0_MASK)) == htonl(ETH0_NET)) {
        // 来自 192.168.1.0/24 → 应走 eth0
        dev = dev_get_by_name(&init_net, "eth0");
    } else if ((saddr & htonl(ETH1_MASK)) == htonl(ETH1_NET)) {
        // 来自 10.0.0.0/8 → 应走 eth1
        dev = dev_get_by_name(&init_net, "eth1");
    } else {
        return NF_ACCEPT;  // 其他源 IP 走默认路由
    }

    if (!dev) return NF_ACCEPT;

    // 查找目标路由
    memset(&fl4, 0, sizeof(fl4));
    fl4.daddr = iph->daddr;
    fl4.flowi4_oif = dev->ifindex;
    fl4.flowi4_tos = RT_TOS(iph->tos);

    rt = ip_route_output_key(&init_net, &fl4);
    if (IS_ERR(rt)) {
        dev_put(dev);
        return NF_ACCEPT;
    }

    // 修改路由
    skb_dst_set(skb, &rt->dst);

    printk(KERN_INFO "SRC_ROUTE: %pI4 -> %pI4 via %s\n",
           &saddr, &iph->daddr, dev->name);

    dev_put(dev);
    return NF_ACCEPT;
}

static struct nf_hook_ops nfho = {
    .hook     = src_routing_hook,
    .pf       = NFPROTO_IPV4,
    .hooknum  = NF_INET_PRE_ROUTING,
    .priority = -149,   // mangle 之后 (-150 + 1)
};

static int __init sr_init(void) {
    return nf_register_net_hook(&init_net, &nfho);
}

static void __exit sr_exit(void) {
    nf_unregister_net_hook(&init_net, &nfho);
}

module_init(sr_init);
module_exit(sr_exit);
MODULE_LICENSE("GPL");

5. fib_trie（路由查找树）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Linux 使用 LC-trie（Level Compressed Trie）存储路由：

传统 Trie：每个节点 256 个子节点（IPv4 全展开）
  → 内存浪费（大量空节点）

LC-trie：压缩空节点
  → 只存储实际使用的路径分支
  → 高度压缩，查找 O(32) = O(1)

示例路由表压缩：
  192.168.1.0/24
  192.168.2.0/24
  10.0.0.0/8
  0.0.0.0/0

LC-trie 结构：
  root
  ├── 192 → 168
  │       ├── 1 → 1/24
  │       └── 2 → 2/24
  ├── 10 → 0/8
  └── 0 → 0/0

5.1 查看内核路由表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 读取 /proc/net/route
struct {
    __be32  daddr;     // 目的地址（十六进制）
    __be32  gateway;   // 网关
    __be32  flags;     // 标志
    __s32   refcnt;    // 引用计数
    __s32   use;       // 使用次数
    __be32  metric;    // 度量
    __be32  mask;      // 掩码
    __u32   mtu;       // MTU
    __u32   window;    // 窗口
    __u16   irtt;      // 初始 RTT
} route_entry;

// 使用示例
#include <stdio.h>

int main() {
    FILE *fp = fopen("/proc/net/route", "r");
    char buf[256];
    
    // 跳过表头
    fgets(buf, sizeof(buf), fp);
    
    while (fgets(buf, sizeof(buf), fp)) {
        unsigned long d, g, m;
        sscanf(buf, "%*s %lx %lx %lx", &d, &g, &m);
        printf("Dest: %s ", inet_ntoa(*(struct in_addr *)&d));
        printf("Gateway: %s ", inet_ntoa(*(struct in_addr *)&g));
        printf("Mask: %s\n", inet_ntoa(*(struct in_addr *)&m));
    }
    fclose(fp);
    return 0;
}

6. 网络命名空间与路由

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# === 网络命名空间 ===
# 每个命名空间有独立的网络栈（路由表、防火墙、连接跟踪）

# 创建命名空间
sudo ip netns add ns1
sudo ip netns add ns2

# 进入命名空间执行命令
sudo ip netns exec ns1 ip addr show
sudo ip netns exec ns1 ip route show

# 命名空间之间通信（veth pair）
sudo ip link add veth0 type veth peer name veth1
sudo ip link set veth0 netns ns1
sudo ip link set veth1 netns ns2

# 配置
sudo ip netns exec ns1 ip addr add 10.0.0.1/24 dev veth0
sudo ip netns exec ns2 ip addr add 10.0.0.2/24 dev veth1
sudo ip netns exec ns1 ip link set veth0 up
sudo ip netns exec ns2 ip link set veth1 up

# 在 ns1 中 ping ns2
sudo ip netns exec ns1 ping 10.0.0.2

# 删除
sudo ip netns delete ns1
sudo ip netns delete ns2
1
2
3
4
5
6
7
8
// 内核中操作网络命名空间
#include <net/net_namespace.h>

struct net *get_net_by_name(const char *name);
void put_net(struct net *net);

// 获取命名空间的路由表
struct fib_table *fib_get_table(struct net *net, u32 id);
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870