Linux-Netfilter机制学习（一）

Linux-Netfilter机制学习（一）

基于Linux2.6.30内核源代码

钩子函数的注册管理

主要说明Netfilter钩子函数的挂载点，hook函数的保存机制，注册方式；

1）  hook的存储机制

钩子函数由一个全局二维链表数组nf_hooks保存

struct list_head nf_hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS] __read_mostly;

首先按照其协议族进行归类存储（第一维代表的意义），主要协议族包括IPV4、IPV6等协议在内；在每个协议族中，根据钩子点顺序排列，Linux系统定义的最大挂载钩子函数的地点为8个，实际常用的为5各，分别是NF_IP_PRE_ROUTING, NF_IP_LOCAL_IN, NF_IP_FORWARD, NF_IP_LOCAL_OUT, NF_IP_POST_ROUTING；在每个钩子点内保存的则是按照钩子函数优先级保存的钩子节点结构nf_hook_ops，在nf_hook_ops中实际存放了钩子函数的内容。

struct nf_hook_ops

{

struct list_head list;

 

/* User fills in from here down. */

nf_hookfn *hook;

struct module *owner;

u_int8_t pf;

unsigned int hooknum;

/* Hooks are ordered in ascending priority. */

int priority;

};

在相应的钩子点调用钩子函数时，则根据协议族和钩子点找到相应的链表入口，然后依次调用该链中的每一个钩子函数对数据包进行操作

2）  hook的管理机制

内核在启动的时候通过netfilter_init函数完成钩子函数的初始化工作；如果需要在相应的钩子点挂载钩子函数，则需要首先定义一个nf_hook_ops结构，在其中实现所需的钩子函数，再调用nf_register_hook将该钩子函数注册到上述的全局二维链表中。

下面先来看一下netfilter_init初始化函数：

void __init netfilter_init(void)

{

int i, h;

/*首先完成全局二维链表的初始化工作*/

for (i = 0; i < ARRAY_SIZE(nf_hooks); i++) {

        for (h = 0; h < NF_MAX_HOOKS; h++)

               INIT_LIST_HEAD(&nf_hooks[i][h]);

}

 

#ifdef CONFIG_PROC_FS

/*在proc文件系统内注册相应的文件选项*/

proc_net_netfilter = proc_mkdir("netfilter", init_net.proc_net);

if (!proc_net_netfilter)

        panic("cannot create netfilter proc entry");

#endif

/*完成proc文件夹netfilter下针对nf_queue的初始化工作，完成读、写等功能*/

if (netfilter_queue_init() < 0)

        panic("cannot initialize nf_queue");

/*完成proc文件夹netfilter下日志文件的初始化工作*/

if (netfilter_log_init() < 0)

        panic("cannot initialize nf_log");

}

   钩子注册函数nf_registre_hook的定义：

/*nf_register_hook就是一个维护双向链表的过程，将要注册的钩子选项hook_ops加入到全局的二维链表结构中（调用钩子函数的过程，自然也就是查找nf_hooks数组的过程了）*/

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;

/*根据协议族和Hook点来查找与当前待注册节点匹配的数组元素*/

list_for_each_entry(elem, &nf_hooks[reg->pf][reg->hooknum], list) {

        /*在同一链表内部按照优先级排序*/

        if (reg->priority < elem->priority)

               break;

}

/*添加节点*/

list_add_rcu(®->list, elem->list.prev);

mutex_unlock(&nf_hook_mutex);

return 0;

}

而对于钩子函数的注销则通过nf_unregister_hook完成，在自己的链表结构中删除本身所属的节点。

void nf_unregister_hook(struct nf_hook_ops *reg)

{

mutex_lock(&nf_hook_mutex);

list_del_rcu(®->list);

mutex_unlock(&nf_hook_mutex);

 

synchronize_net();

}

钩子函数的注册及撤销还能通过nf_register_hooks(struct nf_hook_ops *reg,unsigned int n)及nf_unregister_hooks(struct nf_hook_ops *reg, unsigned int n)来完成一次进行多个函数的处理，通过定义nf_hook_ops结构的数组来完成多个钩子函数的处理，具体过程与上面两个函数类似。

3）  hook的调用

对于各个挂载点上的钩子函数，会在数据包经过内核的特点函数点进行调用。

比如对于NF_IP_PRE_ROUTING挂载点，在IP栈成功接收sk_buff包后处理

int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)

{

…

return NF_HOOK(PF_INET, NF_INET_PRE_ROUTING, skb, dev, NULL,

                     ip_rcv_finish);

}

钩子函数会在处理函数的最后通过NF_HOOK宏完成调用过程

NF_HOOK宏定义如下：

#define NF_HOOK(pf, hook, skb, indev, outdev, okfn) \

NF_HOOK_THRESH(pf, hook, skb, indev, outdev, okfn, INT_MIN)

 

#define NF_HOOK_THRESH(pf, hook, skb, indev, outdev, okfn, thresh)          \

({int __ret;                                                              \

if ((__ret=nf_hook_thresh(pf, hook, (skb), indev, outdev, okfn, thresh, 1)) == 1)\

__ret = (okfn)(skb);                                                \

__ret;})

可以看出nf_hook_thresh是真正的执行函数，只有在该函数返回为1时，才会执行okfn函数，okfn函数是当数据包被允许通过时所进行的处理。

/**

 *     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,

                       int cond)

{

if (!cond)

        return 1;

#ifndef CONFIG_NETFILTER_DEBUG

/*如果钩子函数数组为空，直接返回1*/

if (list_empty(&nf_hooks[pf][hook]))

        return 1;

#endif

return nf_hook_slow(pf, hook, skb, indev, outdev, okfn, thresh);

}

否则通过nf_hook_slow函数完成后续的处理

/* 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 list_head *elem;

unsigned int verdict;

int ret = 0;

 

/* We may already have this, but read-locks nest anyway */

rcu_read_lock();

/*elem为对于该协议类型的钩子挂载点的链表*/

elem = &nf_hooks[pf][hook];

next_hook:

/*nf_iterate函数完成挂载点上所有钩子函数的执行工作*/

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_DROP) {

        kfree_skb(skb);

        ret = -EPERM;

} else if ((verdict & NF_VERDICT_MASK) == NF_QUEUE) {

        if (!nf_queue(skb, elem, pf, hook, indev, outdev, okfn,

                     verdict >> NF_VERDICT_BITS))

               goto next_hook;

}

rcu_read_unlock();

return ret;

}

NF_STOP为2.6内核后新增的选项，其功能和NF_ACCEPT类似但强于NF_ACCEPT,一旦挂接链表中某个hook节点返回NF_STOP,该skb包就立即结束检查而接受,不再进入链表中后续的hook节点,而NF_ACCEPT则还需要进入后续hook点检查。

/*循环执行链表上所有的钩子函数*/

unsigned int nf_iterate(struct list_head *head,

                     struct sk_buff *skb,

                     unsigned int hook,

                     const struct net_device *indev,

                     const struct net_device *outdev,

                     struct list_head **i,

                     int (*okfn)(struct sk_buff *),

                     int hook_thresh)

{

       unsigned int verdict;

 

       /*

        * The caller must not block between calls to this

        * function because of risk of continuing from deleted element.

        */

/*循环遍历链表中所有的钩子函数，并执行，如果对于数据包的处理为NF_ACCEPT，则进入下一个钩子函数，如果对数据包的处理为丢弃，则直接返回，不遍历余下的钩子函数*/

       list_for_each_continue_rcu(*i, head) {

              struct nf_hook_ops *elem = (struct nf_hook_ops *)*i;

 

              if (hook_thresh > elem->priority)

                     continue;

 

              /* Optimization: we don't need to hold module

                 reference here, since function can't sleep. --RR */

              verdict = elem->hook(hook, skb, indev, outdev, okfn);

              if (verdict != NF_ACCEPT) {

#ifdef CONFIG_NETFILTER_DEBUG

                     if (unlikely((verdict & NF_VERDICT_MASK)

                                                 > NF_MAX_VERDICT)) {

                            NFDEBUG("Evil return from %p(%u).\n",

                                   elem->hook, hook);

                            continue;

                     }

#endif

                     if (verdict != NF_REPEAT)

                            return verdict;

                     *i = (*i)->prev;

              }

       }

       /*遍历完所有的钩子函数后，返回*/

       return NF_ACCEPT;

}

对于一个钩子挂载点的处理结束，对于其他钩子函数挂载点的处理都与这个相似，只是调用的位置不同，通过这种机制，伴随着对于一个数据包在内核中的处理流程，完成了各个钩子挂载点上函数的执行。