Netfilter 之 钩子函数注册

通过注册流程代码的分析，能够明确钩子函数的注册流程，理解存储钩子函数的数据结构，如下图（点击图片可查看原图）；

废话不多说，开始分析；

nf_hook_ops是注册的钩子函数的核心结构，字段含义如下所示，一般待注册的钩子函数会组成一个nf_hook_ops数组，在注册过程中调用nf_register_net_hooks将所有规则加入到指定的钩子点；

 struct nf_hook_ops {
     struct list_head    list;

     /* User fills in from here down. */
     nf_hookfn        *hook; /* 钩子函数 */
     struct net_device    *dev; /* 设备 */
     void            *priv; /* 私有数据 */
     u_int8_t        pf; /* 协议族 */
     unsigned int        hooknum; /* 钩子点 */
     /* Hooks are ordered in ascending priority. */
     int            priority; /* 优先级 */
 };

钩子函数nf_hookfn的原型为：

 typedef unsigned int nf_hookfn(void *priv,
                    struct sk_buff *skb,
                    const struct nf_hook_state *state);

nf_register_net_hooks在注册多个钩子函数时使用，它对多个函数顺序调用nf_register_net_hook进行注册，并且在注册失败时进行回滚；

 int nf_register_net_hooks(struct net *net, const struct nf_hook_ops *reg,
               unsigned int n)
 {
     unsigned int i;
     int err = ;

     /* 循环注册钩子函数 */
     for (i = ; i < n; i++) {
         err = nf_register_net_hook(net, &reg[i]);
         /* 失败 */
         if (err)
             goto err;
     }
     return err;

 err:
     /* 注销本次已注册的钩子函数 */
     if (i > )
         nf_unregister_net_hooks(net, reg, i);
     return err;
 }

多个钩子函数在注册之后，是以多个nf_hook_entry实例的链表的形式存在的，其成员如下；

 struct nf_hook_entry {
     struct nf_hook_entry __rcu    *next; /* 下一节点 */
     nf_hookfn            *hook; /* 钩子函数 */
     void                *priv; /* 私有数据 */
     const struct nf_hook_ops    *orig_ops; /* 钩子操作 */
 };

nf_register_net_hook为钩子函数注册的主流程，首先找到钩子点函数的入口，然后根据优先级将当前注册的钩子函数插入到链表中；

 int nf_register_net_hook(struct net *net, const struct nf_hook_ops *reg)
 {
     struct nf_hook_entry __rcu **pp;
     struct nf_hook_entry *entry, *p;

     if (reg->pf == NFPROTO_NETDEV) {
 #ifndef CONFIG_NETFILTER_INGRESS
         if (reg->hooknum == NF_NETDEV_INGRESS)
             return -EOPNOTSUPP;
 #endif
         if (reg->hooknum != NF_NETDEV_INGRESS ||
             !reg->dev || dev_net(reg->dev) != net)
             return -EINVAL;
     }

     /* 找到钩子点链表头部 */
     pp = nf_hook_entry_head(net, reg);
     if (!pp)
         return -EINVAL;

     /* 分配钩子入口结构 */
     entry = kmalloc(sizeof(*entry), GFP_KERNEL);
     if (!entry)
         return -ENOMEM;

     /* 初始化 */
     nf_hook_entry_init(entry, reg);

     mutex_lock(&nf_hook_mutex);

     /* Find the spot in the list */
     /* 找到钩子应该插入的位置 */
     for (; (p = nf_entry_dereference(*pp)) != NULL; pp = &p->next) {
         if (reg->priority < nf_hook_entry_priority(p))
             break;
     }

     /* 插入钩子点 */
     rcu_assign_pointer(entry->next, p);
     rcu_assign_pointer(*pp, entry);

     mutex_unlock(&nf_hook_mutex);
 #ifdef CONFIG_NETFILTER_INGRESS
     if (reg->pf == NFPROTO_NETDEV && reg->hooknum == NF_NETDEV_INGRESS)
         net_inc_ingress_queue();
 #endif
 #ifdef HAVE_JUMP_LABEL
     static_key_slow_inc(&nf_hooks_needed[reg->pf][reg->hooknum]);
 #endif
     return ;
 }

nf_hook_entry_head的作用为查找钩子点函数入口，从这个函数中，我们可以看到，钩子函数存放位置为net->nf.hooks[pf] + hooknum；

 static struct nf_hook_entry __rcu **nf_hook_entry_head(struct net *net, const struct nf_hook_ops *reg)
 {
     if (reg->pf != NFPROTO_NETDEV)
         return net->nf.hooks[reg->pf]+reg->hooknum;

 #ifdef CONFIG_NETFILTER_INGRESS
     if (reg->hooknum == NF_NETDEV_INGRESS) {
         if (reg->dev && dev_net(reg->dev) == net)
             return &reg->dev->nf_hooks_ingress;
     }
 #endif
     return NULL;
 }

进一步查看net结构，其成员为struct netns_nf nf；

 struct net {

 #ifdef CONFIG_NETFILTER
     struct netns_nf        nf;
     struct netns_xt        xt;
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
     struct netns_ct        ct;
 #endif
 #if defined(CONFIG_NF_TABLES) || defined(CONFIG_NF_TABLES_MODULE)
     struct netns_nftables    nft;
 #endif
 #if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
     struct netns_nf_frag    nf_frag;
 #endif
     struct sock        *nfnl;
     struct sock        *nfnl_stash;
 #if IS_ENABLED(CONFIG_NETFILTER_NETLINK_ACCT)
     struct list_head        nfnl_acct_list;
 #endif
 #if IS_ENABLED(CONFIG_NF_CT_NETLINK_TIMEOUT)
     struct list_head    nfct_timeout_list;
 #endif

 };

进一步查看netns_nf结构，其中有如下成员，struct nf_hook_entry __rcu *hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS]; 可见，其钩子函数入口形式为hooks[协议族][钩子点]，在二维数组的每个节点都对应着一个钩子函数链表，内部多个nf_hook_entry通过优先级从小到大排列；

 struct netns_nf {
 #if defined CONFIG_PROC_FS
     struct proc_dir_entry *proc_netfilter;
 #endif
     const struct nf_queue_handler __rcu *queue_handler;
     const struct nf_logger __rcu *nf_loggers[NFPROTO_NUMPROTO];
 #ifdef CONFIG_SYSCTL
     struct ctl_table_header *nf_log_dir_header;
 #endif
     struct nf_hook_entry __rcu *hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
 #if IS_ENABLED(CONFIG_NF_DEFRAG_IPV4)
     bool            defrag_ipv4;
 #endif
 #if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
     bool            defrag_ipv6;
 #endif
 };

协议的定义如下：

 enum {
     NFPROTO_UNSPEC =  ,
     NFPROTO_INET   =  ,
     NFPROTO_IPV4   =  ,
     NFPROTO_ARP    =  ,
     NFPROTO_NETDEV =  ,
     NFPROTO_BRIDGE =  ,
     NFPROTO_IPV6   = ,
     NFPROTO_DECNET = ,
     NFPROTO_NUMPROTO,
 };

IPv4钩子点的定义如下：

 enum nf_inet_hooks {
     NF_INET_PRE_ROUTING,
     NF_INET_LOCAL_IN,
     NF_INET_FORWARD,
     NF_INET_LOCAL_OUT,
     NF_INET_POST_ROUTING,
     NF_INET_NUMHOOKS
 };

注册流程到此为止；