1. 首页
  2. 文章中心
  3. Kernel

Linux netfilter 学习笔记 之八 ip层netfilter的连接跟踪模块初始化 1.全局初始化 2 Ipv4 连接跟踪模块Hook回调函数的注册 3.三层协议、四层协议中连接模块相关的全局变量定义

77 阅读 0 评论
我是靠谱客的博主 结实裙子，最近开发中收集的这篇文章主要介绍Linux netfilter 学习笔记 之八 ip层netfilter的连接跟踪模块初始化 1.全局初始化 2 Ipv4 连接跟踪模块Hook回调函数的注册 3.三层协议、四层协议中连接模块相关的全局变量定义，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

基于linux2.6.21

在上一节中分析了连接跟踪模块相关的数据结构，本节就开始分析连接跟踪模块相关的初始化，下一节理解连接跟踪模块的hook机制。

 

在分析连接跟踪模块代码之前，先说明几点：

1.连接跟踪模块的helper结构能够实现期望连接的建立以及相关协议的ALG功能。

2.连接跟踪为NAT或者状态防火墙的实现提供了依据

 

连接跟踪模块的初始化过程分别在三个地方进行，一个用于注册连接跟踪模块相关的hook回调函数；一个用于创建连接跟踪项与期望连接项相关的slab缓存；一个用于注册连接跟踪中协议相关的变量。

 

1.全局初始化

1.1 nf_conntrack_init

主要是 nf_conntrack_init进行初始化操作，该函数定义在nf_conntrack_core.c中。

主要完成以下功能：

a.设置nf_conntrack_htable_size、nf_conntrack_max的值

b.为nf_conntrack_hash申请内存并初始化

c.为连接跟踪项与期望连接跟踪项创建slab缓存。

  1.    
  2. int __init nf_conntrack_init(void)  
  3. {  
  4. unsigned int i;  
  5. int ret;  
  6.    
  7. 当nf_conntrack_htable_size的值没有设置时，则在内存小于1GB时，  
  8. 使用内存的1/16384作为hash数组的最大值；在内存大于1GB时  
  9. 则最大hash数组的值为8192  
  10. */  
  11. if (!nf_conntrack_htable_size) {  
  12. nf_conntrack_htable_size  
  13. = (((num_physpages << PAGE_SHIFT) / 16384)  
  14.    / sizeof(struct list_head));  
  15. if (num_physpages > (1024 * 1024 * 1024 / PAGE_SIZE))  
  16. nf_conntrack_htable_size = 8192;  
  17. if (nf_conntrack_htable_size < 16)  
  18. nf_conntrack_htable_size = 16;  
  19. }  
  20.    

  1. /* 
  2. 设置nf_conntrack_max的值，即连接跟踪项的最大值。 
  3. 该值取决于nf_conntrack_hash[]数组的最大值，即为 
  4. nf_conntrack_htable_size的8倍。 
  5. */  
  6. nf_conntrack_max = 8 * nf_conntrack_htable_size;  
  7.    
  8. printk("nf_conntrack version %s (%u buckets, %d max)n",  
  9.        NF_CONNTRACK_VERSION, nf_conntrack_htable_size,  
  10.        nf_conntrack_max);  
  11. /* 
  12. hash链表的初始化，申请nf_conntrack_htable_size个hash链表 
  13. */  
  14. nf_conntrack_hash = alloc_hashtable(nf_conntrack_htable_size,  
  15.     &nf_conntrack_vmalloc);  
  16. if (!nf_conntrack_hash) {  
  17. printk(KERN_ERR "Unable to create nf_conntrack_hashn");  
  18. goto err_out;  
  19. }  
  20. /*调用函数nf_conntrack_register_cache创建连接跟踪项相关的slab缓存*/  
  21. ret = nf_conntrack_register_cache(NF_CT_F_BASIC, "nf_conntrack:basic",  
  22.   sizeof(struct nf_conn), NULL);  
  23. if (ret < 0) {  
  24. printk(KERN_ERR "Unable to create nf_conn slab cachen");  
  25. goto err_free_hash;  
  26. }  
  27. /*创建期望连接跟踪项相关的slab缓存*/  
  28. nf_conntrack_expect_cachep = kmem_cache_create("nf_conntrack_expect",  
  29. sizeof(struct nf_conntrack_expect),  
  30. 0, 0, NULL, NULL);  
  31. if (!nf_conntrack_expect_cachep) {  
  32. printk(KERN_ERR "Unable to create nf_expect slab cachen");  
  33. goto err_free_conntrack_slab;  
  34. }  
  35.    
  36. /* 将nf_ct_l3protos中每一个成员的变量都设置成nf_conntrack_generic_l3proto 
  37. ，然后不同的连接跟踪的三层协议初始化时，即会将相应的 
  38. 数组成员的值替换掉*/  
  39. write_lock_bh(&nf_conntrack_lock);  
  40.         for (i = 0; i < PF_MAX; i++)  
  41. nf_ct_l3protos[i] = &nf_conntrack_generic_l3proto;  
  42.         write_unlock_bh(&nf_conntrack_lock);  
  43.    
  44. /* For use by REJECT target */  
  45. ip_ct_attach = __nf_conntrack_attach;  
  46.    
  47. /*将nf_conntrack_untracked的使用计数设置为1，使该数据连接项能不被删除掉*/      
  48. atomic_set(&nf_conntrack_untracked.ct_general.use, 1);  
  49. /*设置变量nf_conntrack_untracked的状态为confirmed，当对一类数据包 
  50. 不想进行连接跟踪时，就会添加如下命令， 
  51. iptables -t raw -A PREROUTING -d x.x.x.x-j NOTRACK，这样在数据包首先进入PRE_ROUTING 
  52. 、OUTPUT链时，就会首先进入raw模块对应注册的hook函数，并将 
  53. 数据包的nfct指针指向存储nf_conntrack_untracked的内存地址*/  
  54. set_bit(IPS_CONFIRMED_BIT, &nf_conntrack_untracked.status);  
  55.    
  56. return ret;  
  57.    
  58. err_free_conntrack_slab:  
  59. nf_conntrack_unregister_cache(NF_CT_F_BASIC);  
  60. err_free_hash:  
  61. free_conntrack_hash(nf_conntrack_hash, nf_conntrack_vmalloc,  
  62.     nf_conntrack_htable_size);  
  63. err_out:  
  64. return -ENOMEM;  
  65. }  


 

1.2init_or_cleanup

在nf_conntrack_standalone.c中定义的函数，主要是调用上1.1中介绍的函数进行初始化，然后在/proc/net文件系统中创建相应的文件以及在/proc/sys/net中创建连接跟踪模块相关的文件

 

 

/*

nf_conntrack_standalone的初始化与销毁函数

对于初始化:

1.调用nf_conntrack_init进行连接模块相关的初始化，主要是

  设置连接跟踪数的最大值、为连接跟踪项或者期望连接跟踪

  创建slab缓存等操作。

2.在proc/net目录下创建连接跟踪相关的文件，主要nf_conntrack、nf_conntrack_expect

  查看如下:

 

  1. # cat /proc/net/stat/nf_conntrack   
  2. entries  searched found new invalid ignore delete delete_list insert insert_failed drop early_drop icmp_error  expect_new expect_create expect_delete  
  3. 00000001  00000027 00000b0b 000035a4 000053e5 000049fb 000034d8 000003c3 000003ea 00000000 00000000 00000000 00000000  00000000 00000000 00000000   
  4. 00000001  00000000 000008e9 00000067 00007eec 00007d2b 00000132 0000008d 00000067 00000000 00000000 00000000 00000000  00000000 00000000 00000000   
  5. #   
  6. # cat /proc/net/nf_conntrack  
  7. /proc/net/nf_conntrack         /proc/net/nf_conntrack_expect  
  8. # cat /proc/net/nf_conntrack  
  9. ipv4     2 unknown  2 492 src=192.168.1.1 dst=224.0.0.1 [UNREPLIED] src=224.0.0.1 dst=192.168.1.1 use=2  
  10. #   
  11. #   
  12. # cat /proc/net/nf_conntrack_expect  
  13. #   
  14. #   


3.在/proc/sys文件系统中创建连接跟踪相关的内容。

 

 

*/

  1. static int init_or_cleanup(int init)  
  2. {  
  3. #ifdef CONFIG_PROC_FS  
  4. struct proc_dir_entry *proc, *proc_exp, *proc_stat;  
  5. #endif  
  6. int ret = 0;  
  7.    
  8. if (!init) goto cleanup;  
  9.    
  10. ret = nf_conntrack_init();  
  11. if (ret < 0)  
  12. goto cleanup_nothing;  
  13.    
  14. #ifdef CONFIG_PROC_FS  
  15. proc = proc_net_fops_create("nf_conntrack", 0440, &ct_file_ops);  
  16. if (!proc) goto cleanup_init;  
  17.    
  18. proc_exp = proc_net_fops_create("nf_conntrack_expect", 0440,  
  19. &exp_file_ops);  
  20. if (!proc_exp) goto cleanup_proc;  
  21.    
  22. proc_stat = create_proc_entry("nf_conntrack", S_IRUGO, proc_net_stat);  
  23. if (!proc_stat)  
  24. goto cleanup_proc_exp;  
  25.    
  26. proc_stat->proc_fops = &ct_cpu_seq_fops;  
  27. proc_stat->owner = THIS_MODULE;  
  28. #endif  
  29. #ifdef CONFIG_SYSCTL  
  30. nf_ct_sysctl_header = register_sysctl_table(nf_ct_net_table, 0);  
  31. if (nf_ct_sysctl_header == NULL) {  
  32. printk("nf_conntrack: can't register to sysctl.n");  
  33. ret = -ENOMEM;  
  34. goto cleanup_proc_stat;  
  35. }  
  36. #endif  
  37.    
  38. return ret;  
  39.    
  40.  cleanup:  
  41. #ifdef CONFIG_SYSCTL  
  42.   unregister_sysctl_table(nf_ct_sysctl_header);  
  43.  cleanup_proc_stat:  
  44. #endif  
  45. #ifdef CONFIG_PROC_FS  
  46. remove_proc_entry("nf_conntrack", proc_net_stat);  
  47.  cleanup_proc_exp:  
  48. proc_net_remove("nf_conntrack_expect");  
  49.  cleanup_proc:  
  50. proc_net_remove("nf_conntrack");  
  51.  cleanup_init:  
  52. #endif /* CNFIG_PROC_FS */  
  53. nf_conntrack_cleanup();  
  54.  cleanup_nothing:  
  55. return ret;  
  56. }  
  57.    


2 Ipv4 连接跟踪模块Hook回调函数的注册

 

Ipv4协议中，注册的连接跟踪模块相关的回调函数有如下几个：

/*

在连接跟踪PRE_ROUTING链上注册的hook回调函数，主要

是分段数据包进行重组。优先级高于ipv4_conntrack_in

*/

  1. static struct nf_hook_ops ipv4_conntrack_defrag_ops = {  
  2. .hook = ipv4_conntrack_defrag,  
  3. .owner = THIS_MODULE,  
  4. .pf = PF_INET,  
  5. .hooknum = NF_IP_PRE_ROUTING,  
  6. .priority = NF_IP_PRI_CONNTRACK_DEFRAG,  
  7. };  
  8. /*PREROUTING链上注册ipv4_conntrack_in，主要是实现为一条数据流 
  9. 创建连接跟踪项等操作*/  
  10. static struct nf_hook_ops ipv4_conntrack_in_ops = {  
  11. .hook = ipv4_conntrack_in,  
  12. .owner = THIS_MODULE,  
  13. .pf = PF_INET,  
  14. .hooknum = NF_IP_PRE_ROUTING,  
  15. .priority = NF_IP_PRI_CONNTRACK,  
  16. };  
  17. /* 
  18. 在连接跟踪LOCAL_OUT链上注册的hook回调函数，主要 
  19. 是分段数据包进行重组。优先级高于ipv4_conntrack_in 
  20. */  
  21.    
  22. static struct nf_hook_ops ipv4_conntrack_defrag_local_out_ops = {  
  23. .hook           = ipv4_conntrack_defrag,  
  24. .owner          = THIS_MODULE,  
  25. .pf             = PF_INET,  
  26. .hooknum        = NF_IP_LOCAL_OUT,  
  27. .priority       = NF_IP_PRI_CONNTRACK_DEFRAG,  
  28. };  
  29. /*LOCALOUT链上注册ipv4_conntrack_in*/  
  30. /*LOCAL_OUT链上注册ipv4_conntrack_local，主要是实现为本机发出的 
  31. 一条数据流创建连接跟踪项等操作*/  
  32. static struct nf_hook_ops ipv4_conntrack_local_out_ops = {  
  33. .hook = ipv4_conntrack_local,  
  34. .owner = THIS_MODULE,  
  35. .pf = PF_INET,  
  36. .hooknum = NF_IP_LOCAL_OUT,  
  37. .priority = NF_IP_PRI_CONNTRACK,  
  38. };  
  39.    
  40. /* helpers */  
  41. /* 
  42. 在POST_ROUTING链上注册ipv4_conntrack_help，根据传递的数据包， 
  43. 找到该数据包关联的连接跟踪项，然后执行该连接跟踪 
  44. 项关联的helper函数，实现期望连接的创建以及ALG等功能。 
  45. */  
  46. static struct nf_hook_ops ipv4_conntrack_helper_out_ops = {  
  47. .hook = ipv4_conntrack_help,  
  48. .owner = THIS_MODULE,  
  49. .pf = PF_INET,  
  50. .hooknum = NF_IP_POST_ROUTING,  
  51. .priority = NF_IP_PRI_CONNTRACK_HELPER,  
  52. };  
  53. /* 
  54. 在LOCAL_IN链上注册ipv4_conntrack_help，根据传递的数据包， 
  55. 找到该数据包关联的连接跟踪项，然后执行该连接跟踪 
  56. 项关联的helper函数，实现期望连接的创建以及ALG等功能。 
  57. */  
  58.    
  59. static struct nf_hook_ops ipv4_conntrack_helper_in_ops = {  
  60. .hook = ipv4_conntrack_help,  
  61. .owner = THIS_MODULE,  
  62. .pf = PF_INET,  
  63. .hooknum = NF_IP_LOCAL_IN,  
  64. .priority = NF_IP_PRI_CONNTRACK_HELPER,  
  65. };  
  66.    
  67.    
  68. /* Refragmenter; last chance. */  
  69. /* 
  70. 在POST_ROUTING链上注册ipv4_confirm。若传递的数据包关联 
  71. 的连接跟踪项还没有被确认，则执行确认操作 
  72. */  
  73. static struct nf_hook_ops ipv4_conntrack_out_ops = {  
  74. .hook = ipv4_confirm,  
  75. .owner = THIS_MODULE,  
  76. .pf = PF_INET,  
  77. .hooknum = NF_IP_POST_ROUTING,  
  78. .priority = NF_IP_PRI_CONNTRACK_CONFIRM,  
  79. };  
  80. /* 
  81. 在PRE_ROUTING链上注册ipv4_confirm。若传递的数据包关联 
  82. 的连接跟踪项还没有被确认，则执行确认操作 
  83. */  
  84.    
  85. static struct nf_hook_ops ipv4_conntrack_local_in_ops = {  
  86. .hook = ipv4_confirm,  
  87. .owner = THIS_MODULE,  
  88. .pf = PF_INET,  
  89. .hooknum = NF_IP_LOCAL_IN,  
  90. .priority = NF_IP_PRI_CONNTRACK_CONFIRM,  
  91. };  
  92.    


 

然后在nf_conntrack_l3proto_ipv4.c的init_or_cleanup里，通过nf_register_hook将以上的nf_hook_ops添加到nf_hooks[][]数组的相应的链表中。

 

 

3.三层协议、四层协议中连接模块相关的全局变量定义

3.1 nf_conntrack_l3proto_ipv4 

定义ipv4协议相关的nf_conntrack_l3proto变量，其中比较重要的是ipv4_pkt_to_tuple、

ipv4_invert_tuple、ipv4_tuple_to_nfattr、 ipv4_nfattr_to_tuple。下面一一分析之。

  1. struct nf_conntrack_l3proto nf_conntrack_l3proto_ipv4 = {  
  2. .l3proto  = PF_INET,  
  3. .name  = "ipv4",  
  4. .pkt_to_tuple  = ipv4_pkt_to_tuple,  
  5. .invert_tuple  = ipv4_invert_tuple,  
  6. .print_tuple  = ipv4_print_tuple,  
  7. .print_conntrack = ipv4_print_conntrack,  
  8. .prepare  = ipv4_prepare,  
  9. .get_features  = ipv4_get_features,  
  10. #if defined(CONFIG_NF_CT_NETLINK) ||   
  11.     defined(CONFIG_NF_CT_NETLINK_MODULE)  
  12. .tuple_to_nfattr = ipv4_tuple_to_nfattr,  
  13. .nfattr_to_tuple = ipv4_nfattr_to_tuple,  
  14. #endif  
  15. .me  = THIS_MODULE,  
  16. };  


3.1.1 ipv4_pkt_to_tuple

功能:根据ip头部获取源ip地址与目的ip地址，并写入tuple变量中。

  1. static int ipv4_pkt_to_tuple(const struct sk_buff *skb, unsigned int nhoff,  
  2.      struct nf_conntrack_tuple *tuple)  
  3. {  
  4. u_int32_t _addrs[2], *ap;  
  5. ap = skb_header_pointer(skb, nhoff + offsetof(struct iphdr, saddr),  
  6. sizeof(u_int32_t) * 2, _addrs);  
  7. if (ap == NULL)  
  8. return 0;  
  9.    
  10. tuple->src.u3.ip = ap[0];  
  11. tuple->dst.u3.ip = ap[1];  
  12.    
  13. return 1;  
  14. }  


3.1.2 ipv4_invert_tuple

功能:根据原始的tuple的源ip、目的ip值，设置reply的tuple值，新的tuple值的源、目的ip值与原始的tuple的源ip、目的ip值是反过来的。

 

  1. static int ipv4_invert_tuple(struct nf_conntrack_tuple *tuple,  
  2.    const struct nf_conntrack_tuple *orig)  
  3. {  
  4. tuple->src.u3.ip = orig->dst.u3.ip;  
  5. tuple->dst.u3.ip = orig->src.u3.ip;  
  6.    
  7. return 1;  
  8. }  
  9.    


3.1.3 ipv4_prepare

/*

1. 计算数据包的三层数据部分相对于skb->data的偏移量。

2.获取四层协议的协议号

*/

  1. static int  
  2. ipv4_prepare(struct sk_buff **pskb, unsigned int hooknum, unsigned int *dataoff,  
  3.      u_int8_t *protonum)  
  4. {  
  5. /* Never happen */  
  6. if ((*pskb)->nh.iph->frag_off & htons(IP_OFFSET)) {  
  7. if (net_ratelimit()) {  
  8. printk(KERN_ERR "ipv4_prepare: Frag of proto %u (hook=%u)n",  
  9. (*pskb)->nh.iph->protocol, hooknum);  
  10. }  
  11. return -NF_DROP;  
  12. }  
  13. *dataoff = (*pskb)->nh.raw - (*pskb)->data + (*pskb)->nh.iph->ihl*4;  
  14. /*获取四层协议号*/  
  15. *protonum = (*pskb)->nh.iph->protocol;  
  16.    
  17. return NF_ACCEPT;  
  18. }  
  19.    


3.1.4 ipv4_tuple_to_nfattr

 

功能:tuple结构中的三层源ip、目的ip地址按照nfnetlink规定的形式进行填充

 

  1. static int ipv4_tuple_to_nfattr(struct sk_buff *skb,  
  2. const struct nf_conntrack_tuple *tuple)  
  3. {  
  4. NFA_PUT(skb, CTA_IP_V4_SRC, sizeof(u_int32_t),  
  5. &tuple->src.u3.ip);  
  6. NFA_PUT(skb, CTA_IP_V4_DST, sizeof(u_int32_t),  
  7. &tuple->dst.u3.ip);  
  8. return 0;  
  9.    
  10. nfattr_failure:  
  11. return -1;  
  12. }  


3.1.5 ipv4_nfattr_to_tuple

功能:将nfnetlink消息传递过来的变量，转换成tuple结构中的三层源ip、目的ip地址，

  1. static int ipv4_nfattr_to_tuple(struct nfattr *tb[],  
  2. struct nf_conntrack_tuple *t)  
  3. {  
  4. if (!tb[CTA_IP_V4_SRC-1] || !tb[CTA_IP_V4_DST-1])  
  5. return -EINVAL;  
  6.    
  7. if (nfattr_bad_size(tb, CTA_IP_MAX, cta_min_ip))  
  8. return -EINVAL;  
  9.    
  10. t->src.u3.ip =  
  11. *(u_int32_t *)NFA_DATA(tb[CTA_IP_V4_SRC-1]);  
  12. t->dst.u3.ip =  
  13. *(u_int32_t *)NFA_DATA(tb[CTA_IP_V4_DST-1]);  
  14.    
  15. return 0;  
  16. }  
  17.    


 

然后在nf_conntrack_l3proto_ipv4.c的init_or_cleanup里，通过nf_conntrack_l3proto_register将nf_conntrack_l3proto_ipv4的地址存放在nf_ct_l3protos[PF_INET]。

 

3.2 nf_conntrack_protocol_tcp4

定义tcp协议相关的nf_conntrack_protocol 变量，其中比较重要的是tcp_pkt_to_tuple、

 tcp_invert_tuple、nf_ct_port_tuple_to_nfattr、 nf_ct_port_nfattr_to_tuple。这几个函数实现的功能与nf_conntrack_l3proto_ipv4中相应的函数相似，只不过ipv4中针对的是ip地址，此处针对的是端口号而已。

而函数tcp_packet主要是针对tcp协议的状态变化而定义的，主要用于状态防火墙的。

  1. struct nf_conntrack_protocol nf_conntrack_protocol_tcp4 =  
  2. {  
  3. .l3proto = PF_INET,  
  4. .proto  = IPPROTO_TCP,  
  5. .name  = "tcp",  
  6. .pkt_to_tuple  = tcp_pkt_to_tuple,  
  7. .invert_tuple  = tcp_invert_tuple,  
  8. .print_tuple  = tcp_print_tuple,  
  9. .print_conntrack  = tcp_print_conntrack,  
  10. .packet  = tcp_packet,  
  11. .new  = tcp_new,  
  12. .error = tcp_error4,  
  13. #if defined(CONFIG_NF_CT_NETLINK) ||   
  14.     defined(CONFIG_NF_CT_NETLINK_MODULE)  
  15. .to_nfattr = tcp_to_nfattr,  
  16. .from_nfattr = nfattr_to_tcp,  
  17. .tuple_to_nfattr = nf_ct_port_tuple_to_nfattr,  
  18. .nfattr_to_tuple = nf_ct_port_nfattr_to_tuple,  
  19. #endif  
  20. };  
  21.    


 

 

然后在nf_conntrack_l3proto_ipv4.c的init_or_cleanup里，通过nf_conntrack_protocol_register将nf_conntrack_protocol_tcp4的地址存放在nf_ct_protos[PF_INET][TCP]。

 

至此，分析完了连接跟踪模块的初始化代码部分。


最后

以上就是结实裙子为你收集整理的Linux netfilter 学习笔记 之八 ip层netfilter的连接跟踪模块初始化 1.全局初始化 2 Ipv4 连接跟踪模块Hook回调函数的注册 3.三层协议、四层协议中连接模块相关的全局变量定义的全部内容，希望文章能够帮你解决Linux netfilter 学习笔记 之八 ip层netfilter的连接跟踪模块初始化 1.全局初始化 2 Ipv4 连接跟踪模块Hook回调函数的注册 3.三层协议、四层协议中连接模块相关的全局变量定义所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(51)

相关文章

(七)洞悉linux下的Netfilter&iptables：如何理解连接跟踪机制？【下】
(七)洞悉linux下的Netfilter&iptables：如何理解连接跟踪机制？【下】
linux 内核 netfilter 网络过滤模块 (4)-期望连接
linux 内核 netfilter 网络过滤模块 (4)-期望连接
连接跟踪子系统之核心实现1. 连接跟踪入口: nf_conntrack_in()2. 连接跟踪子系统出口:nf_conntrack_confirm()3. 连接超时机制
连接跟踪子系统之核心实现1. 连接跟踪入口: nf_conntrack_in()2. 连接跟踪子系统出口:nf_conntrack_confirm()3. 连接超时机制
每日一练20210608
每日一练20210608
Linux netfilter 学习笔记 之八 ip层netfilter的连接跟踪模块初始化 1.全局初始化 2 Ipv4 连接跟踪模块Hook回调函数的注册 3.三层协议、四层协议中连接模块相关的全局变量定义
Linux netfilter 学习笔记 之八 ip层netfilter的连接跟踪模块初始化 1.全局初始化 2 Ipv4 连接跟踪模块Hook回调函数的注册 3.三层协议、四层协议中连接模块相关的全局变量定义
负载均衡原理的解析
负载均衡原理的解析
Linux netfilter 学习笔记 之七 ip层netfilter的连接跟踪模块的概念及相关的数据结构分析 1. 相应的数据结构
Linux netfilter 学习笔记 之七 ip层netfilter的连接跟踪模块的概念及相关的数据结构分析 1. 相应的数据结构
如何理解Netfilter中的连接跟踪机制
如何理解Netfilter中的连接跟踪机制

评论列表共有 0 条评论

立即
投稿
返回
顶部