Linux netfilter源码分析(2)

转贴自http://alexanderlaw.blog.hexun.com/8968771_d.html

 

二、ipt_table数据结构和表的初始化

 

2.1  include/linux/netfilter_ipv4/ip_tables.h   struct  ipt_table 表结构

struct ipt_table
{
struct list_head list;
/* 表链 */
char name[IPT_TABLE_MAXNAMELEN];
/* 表名，如"filter"、"nat"等，为了满足自动模块加载的设计，包含该表的模块应命名为iptable_'name'.o */
struct ipt_replace *table;
/* 表模子，初始为initial_table.repl */
unsigned int valid_hooks;
/* 位向量，标示本表所影响的HOOK */
rwlock_t lock;
/* 读写锁，初始为打开状态 */
struct ipt_table_info *private;
/* iptable的数据区，见下 */
struct module *me;
/* 是否在模块中定义 */
};

 

 

 

2.2  struct ipt_table_info是实际描述表的数据结构 ip_tables.c

struct ipt_table_info
{
unsigned int size;
/* 表大小 */
unsigned int number;
/* 表中的规则数 */
unsigned int initial_entries;
/* 初始的规则数，用于模块计数 */
unsigned int hook_entry[NF_IP_NUMHOOKS];
/* 记录所影响的HOOK的规则入口相对于下面的entries变量的偏移量 */
unsigned int underflow[NF_IP_NUMHOOKS];
/* 与hook_entry相对应的规则表上限偏移量，当无规则录入时，相应的hook_entry和underflow均为0 */
char entries[0] ____cacheline_aligned;
/* 规则表入口 */
};

 

2.3   include/linux/netfilter_ipv4  规则用struct ipt_entry结构表示，包含匹配用的IP头部分、一个Target和0个或多个Match。由于Match数不定，所以一条规则实际的占用空间是可变的。结构定义如下

 

struct ipt_entry
{
struct ipt_ip ip;
/* 所要匹配的报文的IP头信息 */
unsigned int nfcache;
/* 位向量，标示本规则关心报文的什么部分，暂未使用 */
u_int16_t target_offset;
/* target区的偏移，通常target区位于match区之后，而match区则在ipt_entry的末尾；
初始化为sizeof(struct ipt_entry)，即假定没有match */
u_int16_t next_offset;
/* 下一条规则相对于本规则的偏移，也即本规则所用空间的总和，
初始化为sizeof(struct ipt_entry)+sizeof(struct ipt_target)，即没有match */
unsigned int comefrom;
/* 规则返回点，标记调用本规则的HOOK号，可用于检查规则的有效性 */
struct ipt_counters counters;
/* 记录该规则处理过的报文数和报文总字节数 */
unsigned char elems[0];
/*target或者是match的起始位置 */
}

 

 

2.4  iptables的初始化init(void) ，以filter表为例 iptable_filter.c

 

static int __init init(void)

{

       int ret;

 

       if (forward < 0 || forward > NF_MAX_VERDICT) {

              printk("iptables forward must be 0 or 1/n");

              return -EINVAL;

       }

 

       /* Entry 1 is the FORWARD hook */

       initial_table.entries[1].target.verdict = -forward - 1;

 

       /* Register table */

       ret = ipt_register_table(&packet_filter);     //注册filter表

       if (ret < 0)

              return ret;

 

       /* Register hooks */

       ret = nf_register_hook(&ipt_ops[0]);       //注册三个HOOK

       if (ret < 0)

              goto cleanup_table;

 

       ret = nf_register_hook(&ipt_ops[1]);

       if (ret < 0)

              goto cleanup_hook0;

 

       ret = nf_register_hook(&ipt_ops[2]);

       if (ret < 0)

              goto cleanup_hook1;

 

       return ret;

 

 cleanup_hook1:

       nf_unregister_hook(&ipt_ops[1]);

 cleanup_hook0:

       nf_unregister_hook(&ipt_ops[0]);

 cleanup_table:

       ipt_unregister_table(&packet_filter);

 

       return ret;

}

 

 

/* ipt_register_table函数的参数packet_filter包含了待注册表的各个参数 */

static struct ipt_table packet_filter = {

       .name            = "filter",

       .table             = &initial_table.repl,

       .valid_hooks  = FILTER_VALID_HOOKS,

       .lock              = RW_LOCK_UNLOCKED,

       .me         = THIS_MODULE

};

 

/* 上面的&initial_table.repl是一个ipt_replace结构，也就是ipt_table-〉*table的初始值。

下面是ipt_replace结构的定义，它和ipt_table_info很相似，基本上就是用来初始化ipt_table中的ipt_table_info *private的，这个结构不同于ipt_table_info之处在于，它还要保存表的旧的规则信息 */

struct ipt_replace

{

       char name[IPT_TABLE_MAXNAMELEN];   /* 表名 */

       unsigned int valid_hooks;                   /* 影响的hook */

       unsigned int num_entries;                   /* entry数 */

       unsigned int size;                          /* entry的总大小 */

       unsigned int hook_entry[NF_IP_NUMHOOKS];   /* 规则入口的偏移值 */

       unsigned int underflow[NF_IP_NUMHOOKS];  /* 规则的最大偏移值 */

       unsigned int num_counters;                  /* 规则数 */

       struct ipt_counters __user *counters;           

       struct ipt_entry entries[0];                   /* 规则入口 */

};

 

/* 下面是initial_table.repl的初始化 */

static struct

{

       struct ipt_replace repl;

       struct ipt_standard entries[3];

       struct ipt_error term;

} initial_table __initdata

= { { "filter", FILTER_VALID_HOOKS, 4,

      sizeof(struct ipt_standard) * 3 + sizeof(struct ipt_error),

      { [NF_IP_LOCAL_IN] = 0,

       [NF_IP_FORWARD] = sizeof(struct ipt_standard),

       [NF_IP_LOCAL_OUT] = sizeof(struct ipt_standard) * 2 },

      { [NF_IP_LOCAL_IN] = 0,

       [NF_IP_FORWARD] = sizeof(struct ipt_standard),

       [NF_IP_LOCAL_OUT] = sizeof(struct ipt_standard) * 2 },

      0, NULL, { } },

    {

           /* LOCAL_IN */

           { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },

              0,

              sizeof(struct ipt_entry),

              sizeof(struct ipt_standard),

              0, { 0, 0 }, { } },

             { { { { IPT_ALIGN(sizeof(struct ipt_standard_target)), "" } }, { } },

              -NF_ACCEPT - 1 } },

           /* FORWARD */

           { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },

              0,

              sizeof(struct ipt_entry),

              sizeof(struct ipt_standard),

              0, { 0, 0 }, { } },

             { { { { IPT_ALIGN(sizeof(struct ipt_standard_target)), "" } }, { } },

              -NF_ACCEPT - 1 } },

           /* LOCAL_OUT */

           { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },

              0,

              sizeof(struct ipt_entry),

              sizeof(struct ipt_standard),

              0, { 0, 0 }, { } },

             { { { { IPT_ALIGN(sizeof(struct ipt_standard_target)), "" } }, { } },

              -NF_ACCEPT - 1 } }

    },

    /* ERROR */

    { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },

       0,

       sizeof(struct ipt_entry),

       sizeof(struct ipt_error),

       0, { 0, 0 }, { } },

      { { { { IPT_ALIGN(sizeof(struct ipt_error_target)), IPT_ERROR_TARGET } },

         { } },

       "ERROR"

      }

    }

};