利用nf_conntrack机制存储路由，省去每包路由查找

IP是无连接的，因此IP路由是每包一路由的，数据包通过查找路由表获取路由，这是现代操作协议协议栈IP路由的默认处理方式。可是假设协议栈具有流识别能力，是不是能够基于流来路由呢？答案无疑是肯定的。

设计思想

在Linux的实现中，nf_conntrack能够做到基于流的IP路由，大致思想就是，仅仅针对一个流的第一个正向包和第一个反向包查找标准的IP路由表，将结果保存在conntrack项中，兴许的属于同一流的数据包直接取出路由项来使用。背后的思想是：这能够省去查找路由表的开销，是这样吗？也不全是！关键是，将一个数据包相应到一个数据流，这本身就须要一个查找匹配的过程，假设能将路由保存在conntrack里面，那么conntrack查找和路由查找就能够合并成一次查找。因此，查找是免不了的，仅仅是换了地方而已，假设有了conntrack，仍然进行标准的基于包的IP路由查找过程，那就是平白多了一次查找。

实现思想

在实现上，非常easy，那就是尽量在数据包离开协议栈的地方设置skb的路由到conntrack。之所以能够这么做是由于无论是POSTROUTING还是INPUT，都是在路由之后，假设前面进行了基于包的IP路由查找，此时skb上一定绑定了dst_entry，将其绑到conntrack里面就可以。另外，在数据包刚进入协议栈的地方试图从conntrack项中取出路由，然后直接将其设置到skb上。整个处理过程相似skb-mark和conntrack mark的处理方式：
-A PREROUTING -m mark --mark 100 -j ACCEPT
-A PREROUTING -j CONNMARK --restore-mark --nfmask 0xffffffff --ctmask 0xffffffff
-A PREROUTING -m mark ! --mark 0x0 -j ACCEPT
...... 慢速匹配过程
-A PREROUTING .....  -j MARK --set-mark 100
.....慢速匹配过程
-A POSTROUTING -m mark ! --mark 0x0 -j CONNMARK --save-mark --nfmask 0xffffffff --ctmask 0xffffffff 

有了以上的理解，代码就非常easy了

#include <linux/ip.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/version.h>
#include <net/netfilter/nf_conntrack.h>
#include <net/dst.h>
#include <net/netfilter/nf_conntrack_acct.h>

MODULE_AUTHOR("xtt");
MODULE_DESCRIPTION("gll");
MODULE_LICENSE("GPL");
MODULE_ALIAS("XTT and GLL");

struct nf_conn_priv {
        struct nf_conn_counter ncc[IP_CT_DIR_MAX];
        struct dst_entry *dst[IP_CT_DIR_MAX];
};

static unsigned int ipv4_conntrack_getdst (unsigned int hooknum,
                                      struct sk_buff *skb,
                                      const struct net_device *in,
                                      const struct net_device *out,
                                      int (*okfn)(struct sk_buff *))
{
        struct nf_conn *ct;
        enum ip_conntrack_info ctinfo;
        struct nf_conn_counter *acct;
        struct nf_conn_priv *dst_info;
        ct = nf_ct_get(skb, &ctinfo);
        if (!ct || ct == &nf_conntrack_untracked)
                return NF_ACCEPT;
        acct = nf_conn_acct_find(ct);
        if (acct) {
                int dir = CTINFO2DIR(ctinfo);
                dst_info = (struct nf_conn_priv *)acct;
                if (dst_info->dst[dir] == NULL) {
                        dst_hold(skb_dst(skb));
                        dst_info->dst[dir] = skb_dst(skb);
                }
        }
        return NF_ACCEPT;
}

static unsigned int ipv4_conntrack_setdst (unsigned int hooknum,
                                      struct sk_buff *skb,
                                      const struct net_device *in,
                                      const struct net_device *out,
                                      int (*okfn)(struct sk_buff *))
{
        struct nf_conn *ct;
        enum ip_conntrack_info ctinfo;
        struct nf_conn_counter *acct;
        struct nf_conn_priv *dst_info;
        ct = nf_ct_get(skb, &ctinfo);
        if (!ct || ct == &nf_conntrack_untracked)
                return NF_ACCEPT;
        acct = nf_conn_acct_find(ct);
        if (acct) {
                int dir = CTINFO2DIR(ctinfo);
                dst_info = (struct nf_conn_priv *)acct;
                if (dst_info->dst[dir] != NULL) {
                       // 假设在此设置了skb的dst，那么在ip_rcv_finish中就不会再去查找路由表了
                        skb_dst_set(skb, dst_info->dst[dir]);
                }
        }
        return NF_ACCEPT;
}
static struct nf_hook_ops ipv4_conn_dst_info[] __read_mostly = {
        {
                .hook           = ipv4_conntrack_getdst,
                .owner          = THIS_MODULE,
                .pf             = NFPROTO_IPV4,
                .hooknum        = NF_INET_POST_ROUTING,
                .priority       = NF_IP_PRI_CONNTRACK + 1,
        },
        {
                .hook           = ipv4_conntrack_getdst,
                .owner          = THIS_MODULE,
                .pf             = NFPROTO_IPV4,
                .hooknum        = NF_INET_LOCAL_IN,
                .priority       = NF_IP_PRI_CONNTRACK + 1,
        },
        {
                .hook           = ipv4_conntrack_setdst,
                .owner          = THIS_MODULE,
                .pf             = NFPROTO_IPV4,
                .hooknum        = NF_INET_PRE_ROUTING,
                .priority       = NF_IP_PRI_CONNTRACK + 1,
        },
};

static int __init test_info_init(void)
{
        int err;
        err = nf_register_hooks(ipv4_conn_dst_info, ARRAY_SIZE(ipv4_conn_dst_info));
        if (err) {
                return err;
        }
        return err;
}

static void __exit test_info_exit(void)
{
        nf_unregister_hooks(ipv4_conn_dst_info, ARRAY_SIZE(ipv4_conn_dst_info));
}

module_init(test_info_init);
module_exit(test_info_exit);

在以上的实现思想的文字描写叙述中，我使用了尽量和试图两个不那么明白的词，这就牵扯到了流路由的老化机制。

老化思想
标准的路由查找是每一个包都要查找，而现在引入了流路由之后，便不须要对skb进行路由查找了，取而代之的是直接从conntrack取出路由设置给skb，这个conntrack上的路由就是第一次的时候针对skb查找路由表的结果。那么就会引入一个问题，即什么时候再次针对skb查找路由表以便更新conntrack的路由。这个问题没法直接回答，对于路由一直稳定的网络，根本不须要又一次查找，由于针对一个流的第一个正向包和第一个反向包的路由查找结果在该流的生命周期中将一直有效，毕竟路由没有改变，可是假设在流的生命周期内一条相关的路由发生了改变，就须要又一次更新conntrack的路由结果。
       因此能够说，引入一个通知机制就能解决问题。每当路由发生改变的时候，在PREROUTING的hook中，不再运行：

skb_dst_set(skb, dst_info->dst[dir]);

而这个非常easy，使用内核的Notifier机制就能够了，在不论什么路由改变的时候，通知上述的流路由模块改变一个标志位，在PREROUTING的hook中，发现该标志位置位，就不运行skb_dst_set。如此一来，上述的代码就会变为以下的：

static unsigned int ipv4_conntrack_getdst (unsigned int hooknum,
                                      struct sk_buff *skb,
                                      const struct net_device *in,
                                      const struct net_device *out,
                                      int (*okfn)(struct sk_buff *))
{
...
        if (acct) {
                int dir = CTINFO2DIR(ctinfo);
                dst_info = (struct nf_conn_priv *)acct;
        // 无条件设置流的路由。skb的dst可能来自两个地方：
        // 1.来自ipv4_conntrack_setdst；
        // 2.来自标准的IP路由查找
                dst_hold(skb_dst(skb));
                dst_info->dst[dir] = skb_dst(skb);
        }
        return NF_ACCEPT;
}

static unsigned int ipv4_conntrack_setdst (unsigned int hooknum,
                                      struct sk_buff *skb,
                                      const struct net_device *in,
                                      const struct net_device *out,
                                      int (*okfn)(struct sk_buff *))
{
...
        if (acct) {
                int dir = CTINFO2DIR(ctinfo);
                dst_info = (struct nf_conn_priv *)acct;
        // 仅仅有标志为1，才信任流路由，而且设置给skb
                if (flag == 1) {
                        skb_dst_set(skb, dst_info->dst[dir]);
                }
        }
        return NF_ACCEPT;
}

然而，把这件事交给用户态也许更好些。毕竟内核态发生的全部事情，用户态都有办法监控到，我觉得用一个procfs的可写文件来通知flag变为1或者变为0可能更好，即flag的值由用户来设置，这样用户就能够在随意时刻启用，停用流路由机制，比方使用iproute2的monitor机制监控到了路由的改变，假设是无关路由改变了，那么就不更新flag，仅仅有是相关的路由改变了，才更新，何其灵活。