Linux netfilter源码分析(2)

二、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"
}
}
};