for (i =0; i < nr_slots; i++)
   INIT_HLIST_NULLS_HEAD(&hash[i], i);

总结一下初始化完成的数据结构：

 ◇ conntrack模块使用到的SLAB缓存：

1. nf_conntrack_cachep

nf_conntrack_cachep =kmem_cache_create("nf_conntrack",

                                          sizeof(struct nf_conn),

                                          0,SLAB_DESTROY_BY_RCU, NULL);

       构建nf_conn的SLAB缓存，所有的conntrack实例都从这个SLAB缓存中申请。

2. nf_ct_expect_cachep

nf_ct_expect_cachep =kmem_cache_create("nf_conntrack_expect",

                                   sizeof(struct nf_conntrack_expect),

                                   0,0, NULL);

构建nf_conntrack_expect的SLAB缓存，所有的conntrack期望连接实例都从这个SLAB缓存中申请。

◇ net结构中的hash表：

net->ct.hash

struct nf_conntrack_tuple_hash {
	struct hlist_nulls_node hnnode;
	struct nf_conntrack_tuple tuple;
};

struct nf_conn结构：

/* 唯一描述一个连接的状态 */
struct nf_conn {
	......
	/* 两个哈希表，分别为original和reply，新建一个连接就在这两个hash中添加一项nf_conntrack_tuple。*/
	struct nf_conntrack_tuple_hash tuplehash[IP_CT_DIR_MAX];
	union nf_conntrack_proto proto;
	......
};

struct nf_conntrack_tuple结构：

/* 唯一标识一个连接 */
struct nf_conntrack_tuple
{
	struct nf_conntrack_man src;

	/* These are the parts of the tuple which are fixed. */
	struct {
		union nf_inet_addr u3;
		union {
			/* Add other protocols here. */
			__be16 all;

			struct {
				__be16 port;
			} tcp;
			struct {
				__be16 port;
			} udp;
			struct {
				u_int8_t type, code;
			} icmp;
			struct {
				__be16 port;
			} dccp;
			struct {
				__be16 port;
			} sctp;
			struct {
				__be16 key;
			} gre;
		} u;

		/* The protocol. */
		u_int8_t protonum;

		/* The direction (for tuplehash) */
		u_int8_t dir; /* original or reply */
	} dst;
};

net->ct.expect_hash

用于缓存ALG的nf_conn实体，即期望连接。

net->ct.unconfirmed

用于缓存还未被确认conntrack条目，数据包进入路由器后会经过两个conntrack相关的hook点，第一个hook点会新建conntrack条目，但这个条目还没有被确认，因此先放到unconfirm链表中，在经过了协议栈的处理和过滤，如果能够成功到达第二个hook点，才被添加进net->ct.hash中去。

net->ct.dying

用于存放超时并即将被删除的conntrack条目。

nf_ct_ext_types[]和nf_ct_helper_hash

conntrack extensions要用到的结构，extensions一共有4个type，其中helper类型的数据还需要一个额外的hash表，即nf_ct_helper_hash。

系统中conntrack条目可以通过proc文件/proc/net/nf_conntrack查看，文件中的内容可以参考ct_seq_show()函数的实现。

1.2 conntrack_ipv4模块入口

特定于IPv4协议的conntrack模块的初始化内容如下：

nf_conntrack_l3proto_ipv4_init()的工作如上图所示：

1.    初始化socket选项的get方法，可以通过getsockopt()来通过socket得到相应original方向的tuple。

2.    注册tcp4、udp4和icmp三个L4协议到全局的二维数组nf_ct_protos[][]中，其定义如下：

static struct nf_conntrack_l4proto **nf_ct_protos[PF_MAX]__read_mostly;

数组的每个成员都是struct nf_conntrack_l4proto类型的，这里注册的三个成员定义如下：

nf_conntrack_l4proto_tcp4（nf_conntrack_proto_tcp.c）：

struct nf_conntrack_l4proto nf_conntrack_l4proto_tcp4 __read_mostly =
{
	.l3proto		= PF_INET,
	.l4proto 		= IPPROTO_TCP,
	.name 			= "tcp",
	.pkt_to_tuple 		= tcp_pkt_to_tuple,
	.invert_tuple 		= tcp_invert_tuple,
	.print_tuple 		= tcp_print_tuple,
	.print_conntrack 	= tcp_print_conntrack,
	.packet 		= tcp_packet,
	.new 			= tcp_new,
	.error			= tcp_error,
#if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)
	.to_nlattr		= tcp_to_nlattr,
	.nlattr_size		= tcp_nlattr_size,
	.from_nlattr		= nlattr_to_tcp,
	.tuple_to_nlattr	= nf_ct_port_tuple_to_nlattr,
	.nlattr_to_tuple	= nf_ct_port_nlattr_to_tuple,
	.nlattr_tuple_size	= tcp_nlattr_tuple_size,
	.nla_policy		= nf_ct_port_nla_policy,
#endif
#ifdef CONFIG_SYSCTL
	.ctl_table_users	= &tcp_sysctl_table_users,
	.ctl_table_header	= &tcp_sysctl_header,
	.ctl_table		= tcp_sysctl_table,
#ifdef CONFIG_NF_CONNTRACK_PROC_COMPAT
	.ctl_compat_table	= tcp_compat_sysctl_table,
#endif
#endif
};

nf_conntrack_l4proto_udp4（nf_conntrack_proto_udp.c）：

struct nf_conntrack_l4proto nf_conntrack_l4proto_udp4 __read_mostly =
{
	.l3proto		= PF_INET,
	.l4proto		= IPPROTO_UDP,
	.name			= "udp",
	.pkt_to_tuple		= udp_pkt_to_tuple,
	.invert_tuple		= udp_invert_tuple,
	.print_tuple		= udp_print_tuple,
	.packet			= udp_packet,
	.new			= udp_new,
	.error			= udp_error,
#if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)
	.tuple_to_nlattr	= nf_ct_port_tuple_to_nlattr,
	.nlattr_to_tuple	= nf_ct_port_nlattr_to_tuple,
	.nlattr_tuple_size	= nf_ct_port_nlattr_tuple_size,
	.nla_policy		= nf_ct_port_nla_policy,
#endif
#ifdef CONFIG_SYSCTL
	.ctl_table_users	= &udp_sysctl_table_users,
	.ctl_table_header	= &udp_sysctl_header,
	.ctl_table		= udp_sysctl_table,
#ifdef CONFIG_NF_CONNTRACK_PROC_COMPAT
	.ctl_compat_table	= udp_compat_sysctl_table,
#endif
#endif
};

nf_conntrack_l4proto_icmp（nf_conntrack_proto_icmp.c）：

struct nf_conntrack_l4proto nf_conntrack_l4proto_icmp __read_mostly =
{
	.l3proto		= PF_INET,
	.l4proto		= IPPROTO_ICMP,
	.name			= "icmp",
	.pkt_to_tuple		= icmp_pkt_to_tuple,
	.invert_tuple		= icmp_invert_tuple,
	.print_tuple		= icmp_print_tuple,
	.packet			= icmp_packet,
	.new			= icmp_new,
	.error			= icmp_error,
	.destroy		= NULL,
	.me			= NULL,
#if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)
	.tuple_to_nlattr	= icmp_tuple_to_nlattr,
	.nlattr_tuple_size	= icmp_nlattr_tuple_size,
	.nlattr_to_tuple	= icmp_nlattr_to_tuple,
	.nla_policy		= icmp_nla_policy,
#endif
#ifdef CONFIG_SYSCTL
	.ctl_table_header	= &icmp_sysctl_header,
	.ctl_table		= icmp_sysctl_table,
#ifdef CONFIG_NF_CONNTRACK_PROC_COMPAT
	.ctl_compat_table	= icmp_compat_sysctl_table,
#endif
#endif
};

注册是通过nf_conntrack_l4proto_register(l4proto)完成的，参数l4proto是要注册的struct nf_conntrack_l4proto结构，注册步骤为：

1. 如果nf_ct_protos[l4proto->l3proto]还没有初始化，就给该数组元素中的所有数组元素赋值为nf_conntrack_l4proto_generic。
2. 初始化nfnetlink attributes相关的l4proto->nla_size和l4proto->nla_size的值。
3. 将l4proto赋值给nf_ct_protos[l4proto->l3proto][l4proto->l4proto]。

3.    将L3协议nf_conntrack_l3proto_ipv4注册到全局数组nf_ct_l3protos[]中，数组定义如下：

struct nf_conntrack_l3proto *nf_ct_l3protos[AF_MAX]__read_mostly;

struct nf_conntrack_l3proto nf_conntrack_l3proto_ipv4 __read_mostly = {
	.l3proto	 = PF_INET,
	.name		 = "ipv4",
	.pkt_to_tuple	 = ipv4_pkt_to_tuple,
	.invert_tuple	 = ipv4_invert_tuple,
	.print_tuple	 = ipv4_print_tuple,
	.get_l4proto	 = ipv4_get_l4proto,
#if defined(CONFIG_NF_CT_NETLINK) || defined(CONFIG_NF_CT_NETLINK_MODULE)
	.tuple_to_nlattr = ipv4_tuple_to_nlattr,
	.nlattr_tuple_size = ipv4_nlattr_tuple_size,
	.nlattr_to_tuple = ipv4_nlattr_to_tuple,
	.nla_policy	 = ipv4_nla_policy,
#endif
#if defined(CONFIG_SYSCTL) && defined(CONFIG_NF_CONNTRACK_PROC_COMPAT)
	.ctl_table_path  = nf_net_ipv4_netfilter_sysctl_path,
	.ctl_table	 = ip_ct_sysctl_table,
#endif
	.me		 = THIS_MODULE,
};

注册过程是通过nf_conntrack_l3proto_register(proto)完成的，参数proto是要注册的实例，注册步骤如下：

1. 初始化nfnetlink attributes相关的proto->nla_size。
2. 将proto赋值给nf_ct_l3protos[proto->l3proto]。

这里没有给每个成员赋初值，因为在nf_conntrack_init_init_net()函数中已经做过了。

可以看到结构体struct nf_conntrack_l3proto和结构体struct nf_conntrack_l4proto都有pkt_to_tuple()和invert_tuple()函数指针，他们分别作用在数据包的L3头部和L4头部，例如L3的pkt_to_tuple()用于获取源IP和目的IP来初始化tuple，L4的pkt_to_tuple()用于获取源port和目的port来初始化tuple。

总结一下这节初始化的内容：

1. 初始化L4层协议相关的nf_ct_protos[PF_INET][]数组中TCP, UDP, ICMP三个成员。

2. 初始化L3层协议相关的nf_ct_l3protos[PF_INET]。

2. conntrack处理数据包的过程

上一篇文章提到netfilter为conntrack注册了四个hook函数。

下面看一下和conntrack相关的hook函数，即上图中标记为浅蓝色的4个函数，其中ipv4_conntrack_in()和ipv4_conntrack_local()作用相似，他们都位于数据包传输的起点，且优先级仅次于defrag，两个ipv4_confirm()作用相似，他们都位于数据包传输的终点，且优先级最低。

2.1 nf_conntrack_in()

hook函数nf_conntrack_in()的实现如下：

unsigned int
nf_conntrack_in(struct net *net, u_int8_t pf, unsigned int hooknum,
		struct sk_buff *skb)
{
	struct nf_conn *ct;
	enum ip_conntrack_info ctinfo;
	struct nf_conntrack_l3proto *l3proto;
	struct nf_conntrack_l4proto *l4proto;
	unsigned int dataoff;
	u_int8_t protonum;
	int set_reply = 0;
	int ret;

	/* Previously seen (loopback or untracked)?  Ignore. */
	if (skb->nfct) { /* 如果skb已指向一个连接 */
		NF_CT_STAT_INC_ATOMIC(net, ignore);
		return NF_ACCEPT; /* 可能是环回，不做处理 */
	}

	/* 获取skb->data中L4层(TCP, UDP, etc)首部指针和协议类型，赋值给dataoff和protonum */
	l3proto = __nf_ct_l3proto_find(pf);
	ret = l3proto->get_l4proto(skb, skb_network_offset(skb),
				   &dataoff, &protonum);
	if (ret <= 0) { /* 如果返回NF_DROP */
		pr_debug("not prepared to track yet or error occuredn");
		NF_CT_STAT_INC_ATOMIC(net, error);
		NF_CT_STAT_INC_ATOMIC(net, invalid);
		return -ret;
	}

	/* 获取相应L4协议的struct nf_conntrack_l4proto对象。 */
	l4proto = __nf_ct_l4proto_find(pf, protonum);

  if (l4proto->error != NULL)
	{	
		/* 检验L4头部最基本的合法性。如长度, checksum等 */
		ret = l4proto->error(net, skb, dataoff, &ctinfo, pf, hooknum);
		if (ret <= 0) {
			NF_CT_STAT_INC_ATOMIC(net, error);
			NF_CT_STAT_INC_ATOMIC(net, invalid);
			return -ret;
		}
	}

	/* 根据skb得到一个nf_conn结构 */
	ct = resolve_normal_ct(net, skb, dataoff, pf, protonum, 
			       l3proto, l4proto, &set_reply, &ctinfo);
	if (!ct) {
		/* Not valid part of a connection */
		NF_CT_STAT_INC_ATOMIC(net, invalid);
		return NF_DROP;
	}

	if (IS_ERR(ct)) {
		/* Too stressed to deal. */
		NF_CT_STAT_INC_ATOMIC(net, drop);
		return NF_DROP;
	}

	/* 这时skb应该已经指向一个连接了。 */
	NF_CT_ASSERT(skb->nfct);

	/* 对数据包中L4的字段进行合法性检查以及一些协议相关的处理，如修改ct的超时时间，返回处理结果(ACCEPT, DROP etc.) */
	ret = l4proto->packet(ct, skb, dataoff, ctinfo, pf, hooknum);
	if (ret <= 0) { /* 经过上面的packet函数处理失败，就把ct引用删掉 */
		/* Invalid: inverse of the return code tells
		 * the netfilter core what to do */
		pr_debug("nf_conntrack_in: Can't track with proto modulen");
		nf_conntrack_put(skb->nfct);
		skb->nfct = NULL;
		NF_CT_STAT_INC_ATOMIC(net, invalid);
		if (ret == -NF_DROP)
			NF_CT_STAT_INC_ATOMIC(net, drop);
		return -ret;
	}

	/* 如果set_reply=1，即这是reply方向的tuple，就设置ct->status = IPS_SEEN_REPLY_BIT。
	 */
	if (set_reply && !test_and_set_bit(IPS_SEEN_REPLY_BIT, &ct->status))
		nf_conntrack_event_cache(IPCT_STATUS, ct); //空函数

	return ret;
}

resolve_normal_ct()函数用来处理数据包，查找或新建一个tuple，生成一个nf_conn结构：

static inline struct nf_conn *
resolve_normal_ct(struct net *net,
		  struct sk_buff *skb,
		  unsigned int dataoff,
		  u_int16_t l3num,
		  u_int8_t protonum,
		  struct nf_conntrack_l3proto *l3proto,
		  struct nf_conntrack_l4proto *l4proto,
		  int *set_reply,
		  enum ip_conntrack_info *ctinfo)
{
	struct nf_conntrack_tuple tuple;
	struct nf_conntrack_tuple_hash *h = NULL;
	struct nf_conn *ct = NULL;

	/* 由skb得出一个original方向的tuple，赋值给tuple，这是一个struct nf_conntrack_tuple结构，这里给其所有成员都赋值了，以TCP包为例：
tuple->src.l3num = l3num;
tuple->src.u3.ip = srcip;
tuple->dst.u3.ip = dstip;
tuple->dst.protonum = protonum;
tuple->dst.dir = IP_CT_DIR_ORIGINAL;
tuple->src.u.tcp.port = srcport;
tuple->dst.u.tcp.port = destport;
*/
	if (!nf_ct_get_tuple(skb, skb_network_offset(skb),
			     dataoff, l3num, protonum, &tuple, l3proto,
			     l4proto)) {
		pr_debug("resolve_normal_ct: Can't get tuplen");
		return NULL;
	}

	/* 在hash表net->ct.hash中匹配tuple，并初始化其外围的nf_conn结构 */
	h = nf_conntrack_find_get(net, &tuple);
	if (!h) { 
/* 如果没有找到，则创建一对新的tuple（两个方向的tuple是同时创建的）及其
nf_conn结构,并添加到unconfirmed链表中。 */
		h = init_conntrack(net, &tuple, l3proto, l4proto, skb, dataoff);
		if (!h)
			return NULL;
		if (IS_ERR(h))
			return (void *)h;
	}
	ct = nf_ct_tuplehash_to_ctrack(h); /* 获得tuple的nf_conn结构 */

	/* 修改数据包的ct状态。 */
	if (NF_CT_DIRECTION(h) == IP_CT_DIR_REPLY) {
		/* 如果这个tuple是reply方向的 */
		*ctinfo = IP_CT_ESTABLISHED + IP_CT_IS_REPLY;
		/* Please set reply bit if this packet OK */
		*set_reply = 1; /* nf_conntrack_in()要用到这个值=1的时候 */
	} else {
		/* Once we've had two way comms, always ESTABLISHED. */
		if (test_bit(IPS_SEEN_REPLY_BIT, &ct->status)) {
			pr_debug("nf_conntrack_in: normal packet for %pn", ct);
			*ctinfo = IP_CT_ESTABLISHED;
		} else if (test_bit(IPS_EXPECTED_BIT, &ct->status)) { 
			/* 如果在expect链表中找到 */
			pr_debug("nf_conntrack_in: related packet for %pn",
				 ct);
			*ctinfo = IP_CT_RELATED;
		} else {
			pr_debug("nf_conntrack_in: new packet for %pn", ct);
			*ctinfo = IP_CT_NEW;
		}
		*set_reply = 0;
	}

	/* 这里取的地址，由于ct_general是ct的第一个成员，所以skb->nfct保存的是ct的地址。 */
	skb->nfct = &ct->ct_general; 

	/* ct的状态 */
	skb->nfctinfo = *ctinfo;

	return ct;
}

init_conntrack()函数用于分配并初始化一个新的nf_conn结构实例：

/* Allocate a new conntrack: we return -ENOMEM if classification
   failed due to stress.  Otherwise it really is unclassifiable. */
static struct nf_conntrack_tuple_hash *
init_conntrack(struct net *net,
	       struct nf_conntrack_tuple *tuple,
	       struct nf_conntrack_l3proto *l3proto,
	       struct nf_conntrack_l4proto *l4proto,
	       struct sk_buff *skb,
	       unsigned int dataoff
	       )
{
	struct nf_conn *ct;
	struct nf_conn_help *help;
	struct nf_conntrack_tuple repl_tuple;
	struct nf_conntrack_expect *exp;

	/* 根据tuple制作一个repl_tuple。主要是调用L3和L4的invert_tuple方法 */
	if (!nf_ct_invert_tuple(&repl_tuple, tuple, l3proto, l4proto)) {
		pr_debug("Can't invert tuple.n");
		return NULL;
	}

	/* 在cache中申请一个nf_conn结构，把tuple和repl_tuple赋值给ct的tuplehash[]数组，并初始化ct.timeout定时器函数为death_by_timeout()，但不启动定时器。 */
	ct = nf_conntrack_alloc(net, tuple, &repl_tuple, GFP_ATOMIC);
	if (IS_ERR(ct)) {
		pr_debug("Can't allocate conntrack.n");
		return (struct nf_conntrack_tuple_hash *)ct;
	}

	/* 对tcp来说，下面函数就是将L4层字段如window, ack等字段
	赋给ct->proto.tcp.seen[0]，由于新建立的连接才调这里，所以
	不用给reply方向的ct->proto.tcp.seen[1]赋值 */
	if (!l4proto->new(ct, skb, dataoff)) {
		nf_conntrack_free(ct);
		pr_debug("init conntrack: can't track with proto modulen");
		return NULL;
	}

	/* 为acct和ecache两个ext分配空间。不过之后一般不会被初始化，所以用不到 */
	nf_ct_acct_ext_add(ct, GFP_ATOMIC);
	nf_ct_ecache_ext_add(ct, GFP_ATOMIC);

	spin_lock_bh(&nf_conntrack_lock);
	exp = nf_ct_find_expectation(net, tuple);
	 /* 如果在期望连接链表中 */
	if (exp) { /* 将exp的值赋给ct->master */
		pr_debug("conntrack: expectation arrives ct=%p exp=%pn",
			 ct, exp);
		/* Welcome, Mr. Bond.  We've been expecting you... */
		__set_bit(IPS_EXPECTED_BIT, &ct->status);
		ct->master = exp->master;
		if (exp->helper) {
			/* helper的ext以及help链表分配空间 */
			help = nf_ct_helper_ext_add(ct, GFP_ATOMIC);
			if (help)
				rcu_assign_pointer(help->helper, exp->helper);
		}

		/* 如果在expect链表中，将master引用计数加1 */
		nf_conntrack_get(&ct->master->ct_general);
		NF_CT_STAT_INC(net, expect_new);
	} else {
		__nf_ct_try_assign_helper(ct, GFP_ATOMIC);
		NF_CT_STAT_INC(net, new);
	}

	/* 将这个tuple添加到unconfirmed链表中，因为数据包还没有出去，所以不知道是否会被丢弃，所以暂时先不添加到conntrack hash中 */
	hlist_nulls_add_head_rcu(&ct->tuplehash[IP_CT_DIR_ORIGINAL].hnnode,
		       &net->ct.unconfirmed);

	spin_unlock_bh(&nf_conntrack_lock);

	if (exp) {
		/* expect连接的引用计数减1 */
		if (exp->expectfn)
			exp->expectfn(ct, exp);
		nf_ct_expect_put(exp); 
	}

	return &ct->tuplehash[IP_CT_DIR_ORIGINAL];
}

ipv4_conntrack_local()做的事情和nf_conntrack_in()基本相同。可以看到在入口的两个hook点上，conntrack的工作主要是：

1. 由skb得到一个tuple，对数据包做合法性检查。

2. 查找net->ct.hash表是否已记录这个tuple。如果没有记录，则新建一个tuple及nf_conn并添加到unconfirmed链表中。

3. 对ct做一些协议相关的特定处理和检查。

4. 更新conntrack的状态ct->status和skb的状态skb->nfctinfo。

conntrack和skb的状态定义如下：

/* Connection state tracking for netfilter.  This is separated from,
   but required by, the NAT layer; it can also be used by an iptables
   extension. */
/* 一共5个状态，下面四个，加上IP_CT_RELATED + IP_CT_IS_REPLY */
/* 这些值是skb->nfctinfo使用的 */
enum ip_conntrack_info
{
	/* Part of an established connection (either direction). */
	IP_CT_ESTABLISHED, /* enum从0开始。 */

	/* Like NEW, but related to an existing connection, or ICMP error
	   (in either direction). */
	IP_CT_RELATED,

	/* Started a new connection to track (only
           IP_CT_DIR_ORIGINAL); may be a retransmission. */
	IP_CT_NEW,

	/* >= this indicates reply direction */
	IP_CT_IS_REPLY,

	/* Number of distinct IP_CT types (no NEW in reply dirn). */
	IP_CT_NUMBER = IP_CT_IS_REPLY * 2 - 1
};

/* Bitset representing status of connection. */
/* 这些值是ct->status使用的 */
enum ip_conntrack_status {
	/* It's an expected connection: bit 0 set.  This bit never changed */
	IPS_EXPECTED_BIT = 0,
	IPS_EXPECTED = (1 << IPS_EXPECTED_BIT),

	/* We've seen packets both ways: bit 1 set.  Can be set, not unset. */
	IPS_SEEN_REPLY_BIT = 1,
	IPS_SEEN_REPLY = (1 << IPS_SEEN_REPLY_BIT),

	/* Conntrack should never be early-expired. */
	IPS_ASSURED_BIT = 2,
	IPS_ASSURED = (1 << IPS_ASSURED_BIT),

	/* Connection is confirmed: originating packet has left box */
	IPS_CONFIRMED_BIT = 3,
	IPS_CONFIRMED = (1 << IPS_CONFIRMED_BIT),

	/* Connection needs src nat in orig dir.  This bit never changed. */
	IPS_SRC_NAT_BIT = 4,
	IPS_SRC_NAT = (1 << IPS_SRC_NAT_BIT),

	/* Connection needs dst nat in orig dir.  This bit never changed. */
	IPS_DST_NAT_BIT = 5,
	IPS_DST_NAT = (1 << IPS_DST_NAT_BIT),

	/* Both together. */
	IPS_NAT_MASK = (IPS_DST_NAT | IPS_SRC_NAT),

	/* Connection needs TCP sequence adjusted. */
	IPS_SEQ_ADJUST_BIT = 6,
	IPS_SEQ_ADJUST = (1 << IPS_SEQ_ADJUST_BIT),

	/* NAT initialization bits. */
	IPS_SRC_NAT_DONE_BIT = 7,
	IPS_SRC_NAT_DONE = (1 << IPS_SRC_NAT_DONE_BIT),

	IPS_DST_NAT_DONE_BIT = 8,
	IPS_DST_NAT_DONE = (1 << IPS_DST_NAT_DONE_BIT),

	/* Both together */
	IPS_NAT_DONE_MASK = (IPS_DST_NAT_DONE | IPS_SRC_NAT_DONE),

	/* Connection is dying (removed from lists), can not be unset. */
	IPS_DYING_BIT = 9,
	IPS_DYING = (1 << IPS_DYING_BIT),

	/* Connection has fixed timeout. */
	IPS_FIXED_TIMEOUT_BIT = 10,
	IPS_FIXED_TIMEOUT = (1 << IPS_FIXED_TIMEOUT_BIT),
};

我们注意这样一个赋值过程：

在struct nf_conn结构体中，ct_general是其第一个成员，所以它的地址和整个结构体的地址相同，所以skb->nfct的值实际上就是skb对应的conntrack条目的地址，因此通过(struct nf_conn *)skb->nfct就可以通过skb得到它的conntrack条目。

2.2 ipv4_confirm()

hook函数ipv4_confirm()的函数实现如下：

static unsigned int ipv4_confirm(unsigned int hooknum,
				 struct sk_buff *skb,
				 const struct net_device *in,
				 const struct net_device *out,
				 int (*okfn)(struct sk_buff *))
{
	struct nf_conn *ct;
	enum ip_conntrack_info ctinfo;
	const struct nf_conn_help *help;
	const struct nf_conntrack_helper *helper;
	unsigned int ret;

	/* This is where we call the helper: as the packet goes out. */

	/* ct结构从下面获得: (struct nf_conn *)skb->nfct; */
	ct = nf_ct_get(skb, &ctinfo);

	/* 这种状态的不确认 */
	if (!ct || ctinfo == IP_CT_RELATED + IP_CT_IS_REPLY) 
		goto out;

	/* 获得ct->ext中的NF_CT_EXT_HELPER数据。一般都是没有的。ftp，tftp，pptp等这些协议的数据包就会有helper。 */
	help = nfct_help(ct);
	if (!help)
		goto out;

	/* rcu_read_lock()ed by nf_hook_slow */
	helper = rcu_dereference(help->helper);
	if (!helper)
		goto out;

	ret = helper->help(skb, skb_network_offset(skb) + ip_hdrlen(skb),
			   ct, ctinfo);
	if (ret != NF_ACCEPT)
		return ret;

	if (test_bit(IPS_SEQ_ADJUST_BIT, &ct->status)) {
		/* TCP，调整做NAT之后的seq number */
		typeof(nf_nat_seq_adjust_hook) seq_adjust;

		seq_adjust = rcu_dereference(nf_nat_seq_adjust_hook);
		if (!seq_adjust || !seq_adjust(skb, ct, ctinfo)) {
			NF_CT_STAT_INC_ATOMIC(nf_ct_net(ct), drop);
			return NF_DROP;
		}
	}
out:
	/* We've seen it coming out the other side: confirm it */
	return nf_conntrack_confirm(skb);
}

nf_conntrack_confirm()函数：

/* Confirm a connection: returns NF_DROP if packet must be dropped. */
static inline int nf_conntrack_confirm(struct sk_buff *skb)
{
	struct nf_conn *ct = (struct nf_conn *)skb->nfct;
	int ret = NF_ACCEPT;

	if (ct && ct != &nf_conntrack_untracked) {
		/* 如果未被确认 */
		if (!nf_ct_is_confirmed(ct) && !nf_ct_is_dying(ct)) 
			ret = __nf_conntrack_confirm(skb); /* 则进行确认 */
		if (likely(ret == NF_ACCEPT))
			nf_ct_deliver_cached_events(ct); /* 空 */
	}
	return ret;
}

/* Confirm a connection given skb; places it in hash table */
int
__nf_conntrack_confirm(struct sk_buff *skb)
{
	unsigned int hash, repl_hash;
	struct nf_conntrack_tuple_hash *h;
	struct nf_conn *ct;
	struct nf_conn_help *help;
	struct hlist_nulls_node *n;
	enum ip_conntrack_info ctinfo;
	struct net *net;

	ct = nf_ct_get(skb, &ctinfo);
	net = nf_ct_net(ct);

	/* ipt_REJECT uses nf_conntrack_attach to attach related
	   ICMP/TCP RST packets in other direction.  Actual packet
	   which created connection will be IP_CT_NEW or for an
	   expected connection, IP_CT_RELATED. */
/* 如果不是original方向的包，直接返回 */
	if (CTINFO2DIR(ctinfo) != IP_CT_DIR_ORIGINAL) 
		return NF_ACCEPT;

	/* 计算hash key，用于添加进hash表中 */
	hash = hash_conntrack(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple);
	repl_hash = hash_conntrack(&ct->tuplehash[IP_CT_DIR_REPLY].tuple);

	spin_lock_bh(&nf_conntrack_lock);

	/* See if there's one in the list already, including reverse:
	   NAT could have grabbed it without realizing, since we're
	   not in the hash.  If there is, we lost race. */
	/* 待确认的连接如果已经在conntrack的hash表中(有一个方向存在就视为存在)，就不再插入了，丢弃它 */
	hlist_nulls_for_each_entry(h, n, &net->ct.hash[hash], hnnode)
		if(nf_ct_tuple_equal(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple,
				      &h->tuple)) {
			goto out;
                }
	hlist_nulls_for_each_entry(h, n, &net->ct.hash[repl_hash], hnnode)
		if (nf_ct_tuple_equal(&ct->tuplehash[IP_CT_DIR_REPLY].tuple,
				      &h->tuple)) {
			goto out;
               }

	/*从unconfirmed链表中删除该连接 */
	/* Remove from unconfirmed list */
	hlist_nulls_del_rcu(&ct->tuplehash[IP_CT_DIR_ORIGINAL].hnnode);

	/* Timer relative to confirmation time, not original
	   setting time, otherwise we'd get timer wrap in
	   weird delay cases. */
	/* 启动定时器，注意这里的超时时间是L4协议处理后的指定的，如tcp_packet()中由nf_ct_refresh_acct()更新的。 */
	ct->timeout.expires += jiffies;
	add_timer(&ct->timeout);

	/* use加1，设置IPS_CONFIRMED_BIT标志 */
	atomic_inc(&ct->ct_general.use);
	set_bit(IPS_CONFIRMED_BIT, &ct->status);

	/* Since the lookup is lockless, hash insertion must be done after
   * starting the timer and setting the CONFIRMED bit. The RCU barriers
   * guarantee that no other CPU can find the conntrack before the above
   * stores are visible.
   */
   /*  将连接添加进conntrack的hash表(双向链表)中 */
  __nf_conntrack_hash_insert(ct, hash, repl_hash);
	NF_CT_STAT_INC(net, insert);
	spin_unlock_bh(&nf_conntrack_lock);

	return NF_ACCEPT;

out:
	NF_CT_STAT_INC(net, insert_failed);
	spin_unlock_bh(&nf_conntrack_lock);
	return NF_DROP;
}

一个nf_conn的超时处理函数death_by_timeout()，即超时后会执行这个函数：

static void death_by_timeout(unsigned long ul_conntrack)
{
	struct nf_conn *ct = (void *)ul_conntrack;

	if (!test_bit(IPS_DYING_BIT, &ct->status) &&
	    unlikely(nf_conntrack_event(IPCT_DESTROY, ct) < 0)) {
		/* destroy event was not delivered */
		nf_ct_delete_from_lists(ct);
		nf_ct_insert_dying_list(ct);
		return;
	}
	set_bit(IPS_DYING_BIT, &ct->status);
	nf_ct_delete_from_lists(ct);
	nf_ct_put(ct);
}

通过上面的代码，可知在这个hook点上的工作为：

1. 如果该连接存在helper类型的extension数据，就执行其helper函数。

2. 将该conntrack条目从unconfirmed链表中删除，并加入到已确认的链表中，为该条目启动定时器，即该条目已经生效了。

2.3 conntrack extension

conntrack extension用来完成正常的conntrack流程没有考虑的问题，如一些数据包做完NAT后需要调整数据包内容，又如ftp，pptp这些应用层协议需要额外的expect连接。这些工作针对协议有特殊性，无法放在通用处理流程中，于是就出现了conntrack extension。

nf_conn结构中有一个指向本连接extension数据的成员：

struct nf_conn {
	......
	/* Extensions */
	struct nf_ct_ext *ext;
	......
};

这是一个struct nf_ct_ext结构体类型的成员，

struct nf_ct_ext {
	struct rcu_head rcu;
	u8 offset[NF_CT_EXT_NUM];
	u8 len;
	char data[0];
};

从这个结构体的定义可以看出，其数据data是可变长度的，并且可以分为固定的几部分。offset数组指定了每部分数据的位置。

从下面的enum定义可知，data可以由固定位置的4部分组成。当然，一个连接并不需要所有的这些extension数据，一般的UDP/TCP连接只需要NAT数据即可，需要用到期望连接的连接则必须要有HELPER数据。

enum nf_ct_ext_id
{
	NF_CT_EXT_HELPER,
	NF_CT_EXT_NAT,
	NF_CT_EXT_ACCT,
	NF_CT_EXT_ECACHE,
	NF_CT_EXT_NUM,
};

这四种数据分别有自己的数据格式，如下：

#define NF_CT_EXT_HELPER_TYPE struct nf_conn_help
#define NF_CT_EXT_NAT_TYPE struct nf_conn_nat
#define NF_CT_EXT_ACCT_TYPE struct nf_conn_counter
#define NF_CT_EXT_ECACHE_TYPE struct nf_conntrack_ecache

即data中存放的就是这些结构体。

给一个nf_conn->ext赋值都是通过下面函数来完成的：

void * nf_ct_ext_add(struct nf_conn *ct, enum nf_ct_ext_id id, gfp_tgfp);

• 参数ct是nf_conn对象。
• 参数id是extension数据的类型，即上面4个其中的一种。
• 参数gfp是kmalloc的时候的分配方式，这里不关心。
• 函数的返回值是新添加的ext数据指针，即data中新分配空间的位置。返回void *类型，根据参数id可以转换成struct nf_conn_help、struct nf_conn_nat、struct nf_conn_counter或structnf_conntrack_ecache其中的一种类型。

由struct nf_ct_ext结构体定义可知，在给nf_conn->ext分配空间的时候，最主要的一点就是需要知道要添加的类型需要放在data的什么位置，即offset的值。这个值是根据下面的全局数组来确定的：

static struct nf_ct_ext_type *nf_ct_ext_types[NF_CT_EXT_NUM];

这个数组在内核初始化的时候被赋值，初始化完成后这个数组的内容如下。注意，在使用nf_ct_extend_register()注册这几个数组元素时，每个元素的alloc_size会发生改变，总之，这些值在系统启动完成后已经是固定的了。

static struct nf_ct_ext_type *nf_ct_ext_types[NF_CT_EXT_NUM] = {
	{
		.len	= sizeof(struct nf_conn_help),
		.align	= __alignof__(struct nf_conn_help),
		.id	= NF_CT_EXT_HELPER, 
		.alloc_size = ALIGN(sizeof(struct nf_ct_ext), align)
			   + len,
	},
	{
		.len		= sizeof(struct nf_conn_nat),
		.align		= __alignof__(struct nf_conn_nat),
		.destroy	= nf_nat_cleanup_conntrack,
		.move		= nf_nat_move_storage,
		.id		= NF_CT_EXT_NAT, 
		.flags		= NF_CT_EXT_F_PREALLOC,
		.alloc_size = ALIGN(sizeof(struct nf_ct_ext), align)
			   + len,
	},
	{
		.len	= sizeof(struct nf_conn_counter[IP_CT_DIR_MAX]),
		.align	= __alignof__(struct nf_conn_counter[IP_CT_DIR_MAX]),
		.id	= NF_CT_EXT_ACCT, 
		.alloc_size = ALIGN(sizeof(struct nf_ct_ext), align)
			   + len,
	},
	/* 如果没有开启CONFIG_NF_CONNTRACK_EVENTS选项，所以这一项是NULL。
	{
		.len	= sizeof(struct nf_conntrack_ecache),
		.align	= __alignof__(struct nf_conntrack_ecache),
		.id	= NF_CT_EXT_ECACHE, 
		.alloc_size = ALIGN(sizeof(struct nf_ct_ext), align)
			   + len,
	},
	*/
};

下面来看一下nf_ct_ext_add()函数的实现：

/* 根据id给ct->ext分配一个新的ext数据，新数据清0。 */
void *__nf_ct_ext_add(struct nf_conn *ct, enum nf_ct_ext_id id, gfp_t gfp)
{
	struct nf_ct_ext *new;
	int i, newlen, newoff;
	struct nf_ct_ext_type *t;

	/* 如果连ct->ext都还没有，说明肯定没有ext数据。所以先分配一个ct->ext，然后分配类型为id的ext数据，数据位置由ct->ext->offset[id]指向。*/
	if (!ct->ext)
		return nf_ct_ext_create(&ct->ext, id, gfp);

	/* --- ct->ext不为NULL，说明不是第一次分配了 --- */
	
	/* 如果类型为id的数据已经存在，直接返回。 */
	if (nf_ct_ext_exist(ct, id))
		return NULL;

	rcu_read_lock();
	t = rcu_dereference(nf_ct_ext_types[id]);
	BUG_ON(t == NULL);

	/* 找到已有数据的尾端，从这里开始分配新的id的数据。 */
	newoff = ALIGN(ct->ext->len, t->align);
	newlen = newoff + t->len;
	rcu_read_unlock();

	new = __krealloc(ct->ext, newlen, gfp);
	if (!new)
		return NULL;

	/* 由于上面是realloc，可能起始地址改变了，如果变了地址，就先把原有数据考过去。 */
	if (new != ct->ext) {
		for (i = 0; i < NF_CT_EXT_NUM; i++) {
			if (!nf_ct_ext_exist(ct, i))
				continue;

			rcu_read_lock();
			t = rcu_dereference(nf_ct_ext_types[i]);
			if (t && t->move)
				t->move((void *)new + new->offset[i],
					(void *)ct->ext + ct->ext->offset[i]);
			rcu_read_unlock();
		}
		call_rcu(&ct->ext->rcu, __nf_ct_ext_free_rcu);
		ct->ext = new;
	}

	/* 调整ct->ext的offset[id]和len */
	new->offset[id] = newoff;
	new->len = newlen;

	/* 清0。 */
	memset((void *)new + newoff, 0, newlen - newoff);
	return (void *)new + newoff;
}

nf_ct_ext_create()函数：

staticvoid *
nf_ct_ext_create(structnf_ct_ext **ext, enum nf_ct_ext_id id, gfp_t gfp)
{
   unsigned int off, len;
   struct nf_ct_ext_type *t;
 
   rcu_read_lock();
   t = rcu_dereference(nf_ct_ext_types[id]);
   BUG_ON(t == NULL);
   off = ALIGN(sizeof(struct nf_ct_ext),t->align);
   len = off + t->len;
   rcu_read_unlock();
 
   *ext = kzalloc(t->alloc_size, gfp);
   if (!*ext)
       return NULL;
 
   INIT_RCU_HEAD(&(*ext)->rcu);
   (*ext)->offset[id] = off;
   (*ext)->len = len;
 
   /* 由于上面用kzalloc分配时就清0了，所以这里不用清。 */
   return (void *)(*ext) + off;
}