Linux Kernel 学习笔记10：hook函数

inux 内核中有一套hook函数机制，可在不同hook点位置监控网络数据包，并执行丢弃、修改等操作。网络防火墙就是通过此机制实现的。

注册注销hook函数：

linux/netfilter.h

注册钩子函数：
int nf_register_hook(struct nf_hook_ops *reg);
注销：
void nf_unregister_hook(struct nf_hook_ops *reg);

struct nf_hook_ops数据结构：

[cpp]  view plain  copy

1. struct nf_hook_ops {  
2.     struct list_head    list;  
3.   
4.     /* User fills in from here down. */  
5.     nf_hookfn       *hook;          //hook处理函数  
6.     struct net_device   *dev;         
7.     void            *priv;  
8.     u_int8_t        pf;         //协议类型  
9.     unsigned int        hooknum;        //hook点  
10.     /* Hooks are ordered in ascending priority. */  
11.     int         priority;       //优先级  
12. };  

list：链表结构，被注册的nf_hook_ops实际是以链表节点的形式存储在nf_hooks中的，nf_hooks是一个二维数组，后面详细介绍；
hook：hook处理函数，当接收到一个数据包后，调用此函数进行处理；
pf：协议类型，ipv4就选PF_INET；
hooknum：hook点，linux 网络协议栈中包含5个hook，在不同的情况下对数据包进行监控，后面详细介绍；
priority：优先级(越小优先级越高)

HOOK点：
linux网络协议栈中有5个hook点：
之间的关系如下图：


PRE_ROUTING: 所有进入协议栈的数据包都会经过PRE_ROUTING；
LOCAL_IN：经过路由判决，确认是发给本机的数据包会经过LOCAL_IN；
FORWARD：若经路由判决不是发送本机，而且经本机转发的报文会经过FORWARD；
LOCAL_OUT：由本机进程发送出去数据包经过LOCAL_OUT；
POST_ROUTING：所有数据包在离开本机前会经过POST_ROUTING；

linux/netfilter_bridge.h中定义了相关hook点：

[cpp]  view plain  copy

1. /* Bridge Hooks */  
2. /* After promisc drops, checksum checks. */  
3. #define NF_BR_PRE_ROUTING   0  
4. /* If the packet is destined for this box. */  
5. #define NF_BR_LOCAL_IN      1  
6. /* If the packet is destined for another interface. */  
7. #define NF_BR_FORWARD       2  
8. /* Packets coming from a local process. */  
9. #define NF_BR_LOCAL_OUT     3  
10. /* Packets about to hit the wire. */  
11. #define NF_BR_POST_ROUTING  4  

nf_hooks结构：
struct list_head nf_hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
这是一个二维数组，NFPROTO_NUMPROTO表示相关协议，NF_MAX_HOOKS表示hook点位置。被注册的hook操作节点按照优先级接在在这个二位数据后面，如下图：


linux/netfilter_ipv4.h中定义了优先级信息（越小优先级越高）：

[cpp]  view plain  copy

1. enum nf_ip_hook_priorities {  
2.     NF_IP_PRI_FIRST = INT_MIN,  
3.     NF_IP_PRI_CONNTRACK_DEFRAG = -400,  
4.     NF_IP_PRI_RAW = -300,  
5.     NF_IP_PRI_SELINUX_FIRST = -225,  
6.     NF_IP_PRI_CONNTRACK = -200,  
7.     NF_IP_PRI_MANGLE = -150,  
8.     NF_IP_PRI_NAT_DST = -100,  
9.     NF_IP_PRI_FILTER = 0,  
10.     NF_IP_PRI_SECURITY = 50,  
11.     NF_IP_PRI_NAT_SRC = 100,  
12.     NF_IP_PRI_SELINUX_LAST = 225,  
13.     NF_IP_PRI_CONNTRACK_HELPER = 300,  
14.     NF_IP_PRI_CONNTRACK_CONFIRM = INT_MAX,  
15.     NF_IP_PRI_LAST = INT_MAX,  
16. };  

回调函数：
回调函数结构如下：

[cpp]  view plain  copy

1. unsigned int nf_hookfn(void *priv,  
2.         struct sk_buff *skb,  
3.             const struct nf_hook_state *state);  

每监控到一条数据包，就会调用一次次函数，数据包信息存储在sk_buff结构中，参考sk_buff相关介绍。这个函数的返回值决定了函数结束后此数据包的走向，有如下几种返回值：
1. NF_ACCEPT继续正常传输数据报。这个返回值告诉Netfilter：到目前为止，该数据包还是被接受的并且该数据包应当被递交到网络协议栈的下一个阶段。
2. NF_DROP丢弃该数据报，不再传输。
3. NF_STOLEN模块接管该数据报，告诉Netfilter“忘掉”该数据报。该回调函数将从此开始对数据包的处理，并且Netfilter应当放弃对该数据包做任何的处理。但是，这并不意味着该数据包的资源已经被释放。这个数据包以及它独自的sk_buff数据结构仍然有效，只是回调函数从Netfilter获取了该数据包的所有权。
4. NF_QUEUE对该数据报进行排队(通常用于将数据报给用户空间的进程进行处理)
5. NF_REPEAT 再次调用该回调函数，应当谨慎使用这个值，以免造成死循环。

例：
此例程用于捕捉来自192.168.31.4的ping包：

[cpp]  view plain  copy

1. #include <linux/init.h>  
2. #include <linux/module.h>  
3. #include <linux/netfilter.h>  
4. #include <linux/netfilter_bridge.h>  
5. #include <linux/netfilter_ipv4.h>  
6. #include <linux/ip.h>  
7.   
8. static void  
9. IP2Str(char *ipaddr, int size, uint32_t ip)  
10. {  
11.         snprintf(ipaddr, size, "%d.%d.%d.%d", ( ip >> 24 ) & 0xff  
12.                                         , ( ip >> 16 ) & 0xff  
13.                                         , ( ip >> 8 ) & 0xff  
14.                                         , ip & 0xff);  
15. }  
16.   
17. unsigned int  
18. my_hook_fun(void *priv, struct sk_buff *skb, const struct nf_hook_state *state)  
19. {  
20.         struct iphdr *iph;  
21.         char ipaddr[17];  
22.   
23.         if( unlikely(!skb) ) {  
24.                 return NF_ACCEPT;  
25.         }  
26.   
27.         iph = ip_hdr(skb);  
28.         if( unlikely(!iph) ) {  
29.                 return NF_ACCEPT;  
30.         }  
31.   
32.         if( likely(iph->protocol != IPPROTO_ICMP) ) {  
33.                 return NF_ACCEPT;  
34.         }  
35.   
36.         memset(ipaddr, 0, sizeof(ipaddr));  
37.         IP2Str(ipaddr, sizeof(ipaddr), ntohl(iph->saddr));  
38.         if( strcmp(ipaddr, "192.168.31.4") == 0 ) {  
39.                 printk(KERN_INFO "receive ping from 192.168.31.4\n");  
40.         }  
41.   
42.         return NF_ACCEPT;  
43. }  
44.   
45. static struct nf_hook_ops my_hook_ops = {  
46.         .hook           = my_hook_fun,          //hook处理函数  
47.         .pf             = PF_INET,              //协议类型  
48.         .hooknum        = NF_BR_PRE_ROUTING,    //hook注册点  
49.         .priority       = NF_IP_PRI_FIRST,      //优先级  
50. };  
51.   
52. static void  
53. hello_cleanup(void)  
54. {  
55.         nf_unregister_hook(&my_hook_ops);  
56. }  
57.   
58. static __init int hello_init(void)  
59. {  
60.   
61.         if ( nf_register_hook(&my_hook_ops) != 0 ) {  
62.                 printk(KERN_WARNING "register hook error!\n");  
63.                 goto err;  
64.         }  
65.         printk(KERN_ALERT "hello init success!\n");  
66.         return 0;  
67.   
68. err:  
69.         hello_cleanup();  
70.         return -1;  
71. }  
72.   
73. static __exit void hello_exit(void)  
74. {  
75.         hello_cleanup();  
76.         printk(KERN_WARNING "helloworld exit!\n");  
77. }  
78.   
79. module_init(hello_init);  
80. module_exit(hello_exit);  
81.   
82. MODULE_LICENSE("GPL");  
83. MODULE_AUTHOR("Stone");