netfliter 简介

netfilter是在Linux 2.4.X内核引入的一个子系统，它提供了一个抽象的、通用框架，这个框架提供了一整套的钩子函数的管理机制。包括钩子函数的原型定义，注册，注销等。下面将基于Linux 3.14.77 的内核代码简要介绍一下netfilter框架的实现。

netfilter 支持的协议

既然是通用的框架，那么netfilter就需要在数据包流经的关键位置放置钩子。因此，在内核中netfilter支持了多种协议，当数据包经过这些协议的处理流程时就可以执行相应的钩子函数，从而完成对数据包的处理。netfilter支持的协议如下：

enum {
    NFPROTO_UNSPEC =  0,
    NFPROTO_INET   =  1, #
    NFPROTO_IPV4   =  2, # IPV4协议，对应iptables
    NFPROTO_ARP    =  3, # ARP协议， 对应arptables
    NFPROTO_BRIDGE =  7, # 网桥协议， 对应ebtables
    NFPROTO_IPV6   = 10, # IPV6协议，对应ip6tables
    NFPROTO_DECNET = 12,
    NFPROTO_NUMPROTO,
};

支持的协议定义在 include/uapi/linux/netfilter.h

netfilter 模块初始化

int __init netfilter_init(void)
{
    int i, h, ret;

    for (i = 0; i < ARRAY_SIZE(nf_hooks); i++) {
        for (h = 0; h < NF_MAX_HOOKS; h++)
            INIT_LIST_HEAD(&nf_hooks[i][h]);
    }

    ret = register_pernet_subsys(&netfilter_net_ops);
    if (ret < 0)
        goto err;

    ret = netfilter_log_init();
    if (ret < 0)
        goto err_pernet;

    return 0;
err_pernet:
    unregister_pernet_subsys(&netfilter_net_ops);
err:
    return ret;
}

netfliter_init 函数是netfliter内核模块的初始化函数，我们从中可以看到，该函数主要做的工作就是对 extern struct list_head nf_hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS] 全局二维链表数组进行了初始化，nf_hooks二维链表是钩子函数实际挂接的地方，这点将在下文的注册函数中看出来。

netfilter 钩子函数的注册

struct nf_hook_ops {
    struct list_head list;

    /* User fills in from here down. */
    nf_hookfn   *hook;
    struct module   *owner;
    void        *priv;
    u_int8_t    pf;
    unsigned int    hooknum;
    /* Hooks are ordered in ascending priority. */
    int     priority;
};

int nf_register_hooks(struct nf_hook_ops *reg, unsigned int n)
{
    unsigned int i;
    int err = 0;

    for (i = 0; i < n; i++) {
        err = nf_register_hook(&reg[i]);
        if (err)
            goto err;
    }
    return err;

err:
    if (i > 0)
        nf_unregister_hooks(reg, i);
    return err;
}

int nf_register_hook(struct nf_hook_ops *reg)
{
    struct nf_hook_ops *elem;
    int err;

    err = mutex_lock_interruptible(&nf_hook_mutex);
    if (err < 0)
        return err;
    list_for_each_entry(elem, &nf_hooks[reg->pf][reg->hooknum], list) {
        if (reg->priority < elem->priority)
            break;
    }
    list_add_rcu(&reg->list, elem->list.prev);
    mutex_unlock(&nf_hook_mutex);
#if defined(CONFIG_JUMP_LABEL)
    static_key_slow_inc(&nf_hooks_needed[reg->pf][reg->hooknum]);
#endif
    return 0;
}

在使用netfliter框架注册钩子函数时我们需要首先定义一个 struct nf_hook_ops 的实例，然后调用 nf_register_hooks 函数注册自定义的钩子函数。
接下来我们重点分析一下自定义的钩子函数是怎么注册到netfilter框架上的。通过上述代码我们可以看到函数的调用关系是 nf_register_hooks —> nf_register_hook，所以最终注册的动作是在nf_register_hook函数中完成的。

我们再来看下注册的关键流程

int nf_register_hook(struct nf_hook_ops *reg)
{
    struct nf_hook_ops *elem;
    .....................

    list_for_each_entry(elem, &nf_hooks[reg->pf][reg->hooknum], list) {
        if (reg->priority < elem->priority)
            break;
    }
    list_add_rcu(&reg->list, elem->list.prev);
    .....................
    return 0;
}

从关键代码，我们可以看到 nf_hooks[reg->pf][reg->hooknum] 这段代表的是根据struct nf_hook_ops的pf 和 hooknum项找到具体协议挂接点的的链表，然后遍历链表，按优先级递增的顺序插入链表，完成注册。

netfilter 钩子函数的注销

void nf_unregister_hooks(struct nf_hook_ops *reg, unsigned int n)
{
    while (n-- > 0)
        nf_unregister_hook(&reg[n]);
}

void nf_unregister_hook(struct nf_hook_ops *reg)
{
    mutex_lock(&nf_hook_mutex);
    list_del_rcu(&reg->list);
    mutex_unlock(&nf_hook_mutex);
#if defined(CONFIG_JUMP_LABEL)
    static_key_slow_dec(&nf_hooks_needed[reg->pf][reg->hooknum]);
#endif
    synchronize_net();
}

从代码很容易可以看出注销一个钩子函数，就是把该钩子函数从相应的钩子函数链表中删除就行了。其中nf_unregister_hooks 调用 nf_unregister_hook 完成实际的删除操作。

钩子的放置 NF_HOOK 函数

static inline int NF_HOOK(uint8_t pf, unsigned int hook, struct sk_buff *skb,
    struct net_device *in, struct net_device *out,
    int (*okfn)(struct sk_buff *))
{
    return NF_HOOK_THRESH(pf, hook, skb, in, out, okfn, INT_MIN);
}

通过一个实例我们可以看出该函数如何使用

/*
 *  Main IP Receive routine.
 */
int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
{
    const struct iphdr *iph;
    u32 len;
.................

    return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, skb, dev, NULL,
               ip_rcv_finish);
.................

out:
    return NET_RX_DROP;
}

在IPV4的接收函数 ip_rcv 中，我们可以看到 NF_HOOK 函数的用法。对比实例，介绍一下NF_HOOK 函数的形参意义。

NF_HOOK(
uint8_t pf,                           // 关联的协议
unsigned int hook,             // 挂接点
struct sk_buff *skb,           // 数据包
struct net_device *in,       // 接收接口
struct net_device *out,    // 发送接口
int (*okfn)(struct sk_buff *) // 如果经过该挂接点所有钩子函数后数据包被接受，执行的回调函数
)
//函数调用例子
NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, skb, dev, NULL, ip_rcv_finish);

接下来是钩子函数如何被执行的代码，从函数调用流程以及注释我们很容易理解这些钩子函数是怎么执行的。

static inline int
NF_HOOK_THRESH(uint8_t pf, unsigned int hook, struct sk_buff *skb,
           struct net_device *in, struct net_device *out,
           int (*okfn)(struct sk_buff *), int thresh)
{
    int ret = nf_hook_thresh(pf, hook, skb, in, out, okfn, thresh);
    if (ret == 1)
        ret = okfn(skb);
    return ret;
}

/**
 *  nf_hook_thresh - call a netfilter hook
 *  
 *  Returns 1 if the hook has allowed the packet to pass.  The function
 *  okfn must be invoked by the caller in this case.  Any other return
 *  value indicates the packet has been consumed by the hook.
 */
static inline int nf_hook_thresh(u_int8_t pf, unsigned int hook,
                 struct sk_buff *skb,
                 struct net_device *indev,
                 struct net_device *outdev,
                 int (*okfn)(struct sk_buff *), int thresh)
{
    if (nf_hooks_active(pf, hook))
        return nf_hook_slow(pf, hook, skb, indev, outdev, okfn, thresh);
    return 1;
}

static inline bool nf_hooks_active(u_int8_t pf, unsigned int hook)
{
    return !list_empty(&nf_hooks[pf][hook]);
}

/* Returns 1 if okfn() needs to be executed by the caller,
 * -EPERM for NF_DROP, 0 otherwise. */
int nf_hook_slow(u_int8_t pf, unsigned int hook, struct sk_buff *skb,
         struct net_device *indev,
         struct net_device *outdev,
         int (*okfn)(struct sk_buff *),
         int hook_thresh)
{
    struct nf_hook_ops *elem;
    unsigned int verdict;
    int ret = 0;

    /* We may already have this, but read-locks nest anyway */
    rcu_read_lock();

    elem = list_entry_rcu(&nf_hooks[pf][hook], struct nf_hook_ops, list);
next_hook:
    verdict = nf_iterate(&nf_hooks[pf][hook], skb, hook, indev,
                 outdev, &elem, okfn, hook_thresh);
    if (verdict == NF_ACCEPT || verdict == NF_STOP) {
        ret = 1;
    } else if ((verdict & NF_VERDICT_MASK) == NF_DROP) {
        kfree_skb(skb);
        ret = NF_DROP_GETERR(verdict);
        if (ret == 0)
            ret = -EPERM;
    } else if ((verdict & NF_VERDICT_MASK) == NF_QUEUE) {
        int err = nf_queue(skb, elem, pf, hook, indev, outdev, okfn,
                        verdict >> NF_VERDICT_QBITS);
        if (err < 0) {
            if (err == -ECANCELED)
                goto next_hook;
            if (err == -ESRCH &&
               (verdict & NF_VERDICT_FLAG_QUEUE_BYPASS))
                goto next_hook;
            kfree_skb(skb);
        }
    }
    rcu_read_unlock();
    return ret;
}

总结

至此，我们大概了解了内核 netfilter 模块的整个结构是怎么样的了。它首先定义一个全局的二维数组nf_hooks，用于保存支持的协议类型以及各个协议支持的挂接点，然后其他基于netfilter 架构的模块通过定义 struct nf_hook_ops 实例并填充里面的各个选项，调用 nf_register_hook 函数注册该钩子到相应的位置，在数据包流经各个挂接点时，NF_HOOK 函数会遍历该挂接点注册的所有钩子函数完成对数据包的操作， 依赖netfilter 的模块在卸载时，通过调用 nf_unregister_hook 来注销挂接的钩子。