连接跟踪的源代码分析

 

关于连接跟踪

 

连接跟踪（CONNTRACK），就是跟踪并且记录连接状态。Linux为每一个经过网络堆栈的数据包，生成一个新的连接记录项（Connection entry）。此后，所有属于此连接的数据包都被唯一地分配给这个连接，并标识连接的状态。连接跟踪是防火墙模块的状态检测的基础，同时也是地址转换中实现SNAT和DNAT的前提。

 

1.    连接跟踪的相关结构

Netfilter中的连接记录项，即是对一个连接的产生，传输及终止进行跟踪记录。由所有记录项产生的表则称为连接跟踪表，这个表将存储所有连接的状态，它在算法上采用了hash算法。整个hash表用一个ip_conntrack_hash的全局指针来表示：

unsigned int ip_conntrack_htable_size = 0; //由多少条链构成hash表

int ip_conntrack_max = 0; //hash表的大小 后面将根据内存的大小计算

struct list_head *ip_conntrack_hash; //全局hash表

 

每个hash的节点同时又是一个链表的头部。节点的结构体为ip_conntrack_tuple_hash，

/* Connections have two entries in the hash table: one for each way */

struct ip_conntrack_tuple_hash

{

    struct list_head list;//链表

    struct ip_conntrack_tuple tuple;//描述数据包的多元组

    /* this == &ctrack->tuplehash[DIRECTION(this)]. */

    struct ip_conntrack *ctrack;

};

从socket编程的角度来说，使用 ip地址+端口的方式来标识一个连接。Netfilter延续了这种方式，使用ip_conntrack_tuple封装了连接的目的和来源。可以通过一个skbuff（网络数据包）得到这个元组。

 

 

1. /* The protocol-specific manipulable parts of the tuple: always in
3.    network order! */
5. union ip_conntrack_manip_proto
7. {
9.     /* Add other protocols here. */
11.     u_int32_t all;
13.     struct {
15.         u_int16_t port;
17.     } tcp;
19.     struct {
21.         u_int16_t port;
23.     } udp;
25.     struct {
27.         u_int16_t id;
29.     } icmp;
31.     struct {
33.         u_int32_t key;
35.     } gre;
37. };
41. /* The manipulable part of the tuple. */
43. struct ip_conntrack_manip
45. {
47.     u_int32_t ip;
49.     union ip_conntrack_manip_proto u;
51. };
53. /* This contains the information to distinguish a connection. */
55. struct ip_conntrack_tuple
57. {
59.     struct ip_conntrack_manip src; //源端
61.     /* These are the parts of the tuple which are fixed. */
63.     struct {
65.         u_int32_t ip;
67.         union {
69.             /* Add other protocols here. */
71.             u_int32_t all;
73.             struct {
75.                 u_int16_t port;
77.             } tcp;
79.             struct {
81.                 u_int16_t port;
83.             } udp;
85.             struct {
87.                 u_int8_t type, code;
89.             } icmp;
91.             struct {
93.                 u_int32_t key;
95.             } gre;
97.         } u;
99.         /* The protocol. */
101.         u_int16_t protonum;
103.     } dst;//目的端
105. };  

注意tuple可以完全标识一个唯一的连接，但是它不能完整的描述一个连接的信息，描述一个连接的信息，使用ip_conntrack结构体,在ip_conntrack中有tuplehash[IP_CT_DIR_MAX]，这个数组中包含“初始”和“应答”两个成员（tuplehash[IP_CT_DIR_ORIGINAL]和tuplehash[IP_CT_DIR_REPLY]），所以，当一个数据包进入连接跟踪模块后，先根据这个数据包的套接字对转换成一个“初始的”tuple，赋值给tuplehash[IP_CT_DIR_ORIGINAL]，然后对这个数据包“取反”，计算出“应答”的tuple，赋值给tuplehash[IP_CT_DIR_REPLY]。

struct ip_conntrack

{

//…

/* These are my tuples; original and reply */

    struct ip_conntrack_tuple_hash tuplehash[IP_CT_DIR_MAX];

//…

};

 

2.    连接跟踪的具体过程  

连接跟踪是在ip_conntrack_standalone.c 中进行初始化的，并完成向Netfilter注册相关的钩子。

模块的init函数会调用init_or_cleanup()，在init_or_cleanup()中首先调用了ip_conntrack_init()，这个函数主要负责初始化连接跟踪的变量及相关的数据结构例如，连接跟踪表的大小。而后init_or_cleanup（）函数又注册了几个非常重要的钩子。如下：

static int init_or_cleanup(int init)

{ 

    ip_conntrack_init();

    nf_register_hook(&ip_conntrack_in_ops);

    nf_register_hook(&ip_conntrack_local_out_ops);

    nf_register_hook(&ip_conntrack_out_ops);

    nf_register_hook(&ip_conntrack_local_in_ops);

}

钩子的结构体具体如下：

/* Connection tracking may drop packets, but never alters them, so

   make it the first hook. */

static struct nf_hook_ops ip_conntrack_in_ops

= { { NULL, NULL }, ip_conntrack_in, PF_INET, NF_IP_PRE_ROUTING,

    NF_IP_PRI_CONNTRACK };

static struct nf_hook_ops ip_conntrack_local_out_ops

= { { NULL, NULL }, ip_conntrack_local, PF_INET, NF_IP_LOCAL_OUT,

    NF_IP_PRI_CONNTRACK };

/* Refragmenter; last chance. */

static struct nf_hook_ops ip_conntrack_out_ops

= { { NULL, NULL }, ip_refrag, PF_INET, NF_IP_POST_ROUTING, NF_IP_PRI_LAST };

static struct nf_hook_ops ip_conntrack_local_in_ops

= { { NULL, NULL }, ip_confirm, PF_INET, NF_IP_LOCAL_IN, NF_IP_PRI_LAST-1 };  

 

由上面的代码可以看出输入的数据包将首先经过ip_conntrack_in()函数（NF_IP_PRI_CONNTRACK优先级比较高）。在ip_conntrack_in的主要任务为判断该数据包是否已经有连接跟踪，如果没有，则为这个数据包分配ip_conntrack，并初始化它。在ip_conntrack_in()函数会进一步调用resolve_normal_ct（）函数，resolve_normal_ct（）为连接跟踪中最重要的一个函数，它主要完成了ip_conntrack_in（）函数提供的功能。

1. /* On success, returns conntrack ptr, sets skb->nfct and ctinfo */
3. //nfct字段将在ip_conntrack_in中被检测，表示当前数据包是否已被处理过
5. static inline struct ip_conntrack *
7. resolve_normal_ct(struct sk_buff *skb,
9.           struct ip_conntrack_protocol *proto,
11.           int *set_reply,
13.           unsigned int hooknum,
15.           enum ip_conntrack_info *ctinfo)
17. {
19.     struct ip_conntrack_tuple tuple;
21.     struct ip_conntrack_tuple_hash *h;
25.     IP_NF_ASSERT((skb->nh.iph->frag_off & htons(IP_OFFSET)) == 0);
27.     //从Skbuff中提取tuple信息
29.     if (!ip_ct_get_tuple(skb->nh.iph, skb->len, &tuple, proto))
31.         return NULL;
33.     /* look for tuple match */
35.     //在全局的连接跟踪链表中查询该tuple
37. h = ip_conntrack_find_get(&tuple, NULL);
39.     if (!h) {
41.         //如果不存在，初始化一个
43.         h = init_conntrack(&tuple, proto, skb);
45.         if (!h)
47.             return NULL;
49.         if (IS_ERR(h))
51.             return (void *)h;
53.         if (ipctinit_callback)
55.             ipctinit_callback(h->ctrack);
58.     }
62.     /* It exists; we have (non-exclusive) reference. */
64.     //判断连接方向
66.     if (DIRECTION(h) == IP_CT_DIR_REPLY) {
68.         *ctinfo = IP_CT_ESTABLISHED + IP_CT_IS_REPLY;
70.         /* Please set reply bit if this packet OK */
72.         *set_reply = 1;
74.     } else {
76.         /* Once we've had two way comms, always ESTABLISHED. */
78.         if (test_bit(IPS_SEEN_REPLY_BIT, &h->ctrack->status)) {
80.             DEBUGP("ip_conntrack_in: normal packet for %p/n",
82.                    h->ctrack);
84.                 *ctinfo = IP_CT_ESTABLISHED;
86.         } else if (test_bit(IPS_EXPECTED_BIT, &h->ctrack->status)) {
88.             DEBUGP("ip_conntrack_in: related packet for %p/n",
90.                    h->ctrack);
92.             *ctinfo = IP_CT_RELATED;
94.         } else {
96.             DEBUGP("ip_conntrack_in: new packet for %p/n",
98.                    h->ctrack);
100.             *ctinfo = IP_CT_NEW;
102.         }
104.         *set_reply = 0;
106.     }
108.     //每个sk_buff都将与ip_conntrack的一个状态关联，所以从sk_buff可以得到相应ip_conntrack的状态，即数据包的状态
110.     skb->nfct = &h->ctrack->infos[*ctinfo];
112.     return h->ctrack;
114. }

 

初始化一个连接跟踪时，会调用init_conntrack()函数

 

 

3. /* Allocate a new conntrack: we return -ENOMEM if classification
5.    failed due to stress.  Otherwise it really is unclassifiable. */
7. static struct ip_conntrack_tuple_hash *
9. init_conntrack(const struct ip_conntrack_tuple *tuple,
11.            struct ip_conntrack_protocol *protocol,
13.            struct sk_buff *skb)
15. {
17.     struct ip_conntrack *conntrack;
19.     struct ip_conntrack_tuple repl_tuple;
21.     size_t hash;
23.     struct ip_conntrack_expect *expected;
25.     int i;
27.     static unsigned int drop_next = 0;
29.     //计算hash值的随机数种子
31.     if (!ip_conntrack_hash_rnd_initted) {
33.         get_random_bytes(&ip_conntrack_hash_rnd, 4);
35.         ip_conntrack_hash_rnd_initted = 1;
37.     }
39.     
41.     //计算hash值
43.     hash = hash_conntrack(tuple);
45.     //判断连接跟踪表是否已满
47.     if (ip_conntrack_max &
49.         atomic_read(&ip_conntrack_count) >= ip_conntrack_max) {
51.         /* Try dropping from random chain, or else from the
53.                    chain about to put into (in case they're trying to
55.                    bomb one hash chain). */
57.         unsigned int next = (drop_next++)%ip_conntrack_htable_size;
61.         if (!early_drop(&ip_conntrack_hash[next])
63.             && !early_drop(&ip_conntrack_hash[hash])) {
65.             if (net_ratelimit())
67.                 printk(KERN_WARNING
69.                        "ip_conntrack: table full, dropping"
71.                        " packet./n");
73.             return ERR_PTR(-ENOMEM);
75.         }
77.     }
79.     //计算反向的tuple值
81.     if (!invert_tuple(&repl_tuple, tuple, protocol)) {
83.         DEBUGP("Can't invert tuple./n");
85.         return NULL;
87.     }
89.     //为连接分配空间
91.     conntrack = kmem_cache_alloc(ip_conntrack_cachep, GFP_ATOMIC);
93.     if (!conntrack) {
95.         DEBUGP("Can't allocate conntrack./n");
97.         return ERR_PTR(-ENOMEM);
99.     }
103.     memset(conntrack, 0, sizeof(*conntrack));
105.     //设置计数器
107.     atomic_set(&conntrack->ct_general.use, 1);
109.     conntrack->ct_general.destroy = destroy_conntrack;
111.     //设置正反方向的tuple
113. conntrack->tuplehash[IP_CT_DIR_ORIGINAL].tuple = *tuple;
115.     conntrack->tuplehash[IP_CT_DIR_ORIGINAL].ctrack = conntrack;
117.     conntrack->tuplehash[IP_CT_DIR_REPLY].tuple = repl_tuple;
119.     conntrack->tuplehash[IP_CT_DIR_REPLY].ctrack = conntrack;
121.     for (i=0; i < IP_CT_NUMBER; i++)
123.         conntrack->infos[i].master = &conntrack->ct_general;
127.     if (!protocol->new(conntrack, skb->nh.iph, skb->len)) {
129.         kmem_cache_free(ip_conntrack_cachep, conntrack);
131.         return NULL;
133.     }
135.     /* Don't set timer yet: wait for confirmation */
137.     //初始化计数器
139.     init_timer(&conntrack->timeout);
141.     conntrack->timeout.data = (unsigned long)conntrack;
143.     conntrack->timeout.function = death_by_timeout;
147.     INIT_LIST_HEAD(&conntrack->sibling_list);
151.     WRITE_LOCK(&ip_conntrack_lock);
153.     /* Need finding and deleting of expected ONLY if we win race */
155.     //判断是不是期待的子连接
157.     READ_LOCK(&ip_conntrack_expect_tuple_lock);
159.     expected = LIST_FIND(&ip_conntrack_expect_list, expect_cmp,
161.                  struct ip_conntrack_expect *, tuple);
163.     READ_UNLOCK(&ip_conntrack_expect_tuple_lock);
167.     /* If master is not in hash table yet (ie. packet hasn't left
169.        this machine yet), how can other end know about expected?
171.        Hence these are not the droids you are looking for (if
173.        master ct never got confirmed, we'd hold a reference to it
175.        and weird things would happen to future packets). */
177.     //主连接不在hash表中，这应该不是个正确被期待的子连接
179. if (expected && !is_confirmed(expected->expectant))
181.         expected = NULL;
183.     //为一个主连接查找是否由注册的的helper函数
185.     /* Look up the conntrack helper for master connections only */
187.     if (!expected)
189.         conntrack->helper = ip_ct_find_helper(&repl_tuple);
191.     //等待已经超时了
193.     /* If the expectation is dying, then this is a looser. */
195.     if (expected
197.         && expected->expectant->helper->timeout
199.         && ! del_timer(&expected->timeout))
201.         expected = NULL;
203.     //是个被期待的子连接
205.     if (expected) {
207.         DEBUGP("conntrack: expectation arrives ct=%p exp=%p/n",
209.             conntrack, expected);
211.         /* Welcome, Mr. Bond.  We've been expecting you... */
213.         __set_bit(IPS_EXPECTED_BIT, &conntrack->status);
215.         conntrack->master = expected;
217.         expected->sibling = conntrack;
219.         //已经等到了，需要了从等待链表中删掉该连接
221. LIST_DELETE(&ip_conntrack_expect_list, expected);
223.         expected->expectant->expecting--;
225.         nf_conntrack_get(&master_ct(conntrack)->infos[0]);
227.     }
229.     //没有直接将该连接加入hash表，而是加入unconfirmed链表
231.     /* Overload tuple linked list to put us in unconfirmed list. */
233.     list_add(&conntrack->tuplehash[IP_CT_DIR_ORIGINAL].list,
235.              &unconfirmed);
237.     atomic_inc(&ip_conntrack_count);
239.     WRITE_UNLOCK(&ip_conntrack_lock);
241.     if (expected && expected->expectfn)
243.         expected->expectfn(conntrack);
245.     return &conntrack->tuplehash[IP_CT_DIR_ORIGINAL];
247. }

    由上面 的list_add(&conntrack->tuplehash[IP_CT_DIR_ORIGINAL].list, &unconfirmed);

可以看出，在init_conntrack函数中，并没有将一个新建连接的tuple放入全局的连接跟踪表（ip_conntrack_hash）中，那是在什么地方完成的这个任务呢，答案是__ip_conntrack_confirm函数，在Init_or_cleanup函数在NF_IP_POST_ROUTING中注册了ip_refrag函数,而在这个函数中最终会调用__ip_conntrack_confirm函数将tuple加入全局的连接跟踪表，同时把对应项从unconfirmed的队列中删除，代码如下：

 

 

1. /* Confirm a connection given skb->nfct; places it in hash table */
3. Int  __ip_conntrack_confirm(struct nf_ct_info *nfct)
5. {
7.     unsigned int hash, repl_hash;
9.     struct ip_conntrack *ct;
11.     enum ip_conntrack_info ctinfo;
15.     ct = __ip_conntrack_get(nfct, &ctinfo);
19.     /* ipt_REJECT uses ip_conntrack_attach to attach related
21.        ICMP/TCP RST packets in other direction.  Actual packet
23.        which created connection will be IP_CT_NEW or for an
25.        expected connection, IP_CT_RELATED. */
27.     if (CTINFO2DIR(ctinfo) != IP_CT_DIR_ORIGINAL)
29.         return NF_ACCEPT;
31.     //计算正反tuple的hash值
33.     hash = hash_conntrack(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple);
35.     repl_hash = hash_conntrack(&ct->tuplehash[IP_CT_DIR_REPLY].tuple);
39.     /* We're not in hash table, and we refuse to set up related
41.        connections for unconfirmed conns.  But packet copies and
43.        REJECT will give spurious warnings here. */
45.     /* IP_NF_ASSERT(atomic_read(&ct->ct_general.use) == 1); */
49.     /* No external references means noone else could have
51.            confirmed us. */
53.     IP_NF_ASSERT(!is_confirmed(ct));
55.     DEBUGP("Confirming conntrack %p/n", ct);
57.     //给全局连接跟踪表加写锁
59.     WRITE_LOCK(&ip_conntrack_lock);
61.     /* See if there's one in the list already, including reverse:
63.            NAT could have grabbed it without realizing, since we're
65.            not in the hash.  If there is, we lost race. */
67.     if (!LIST_FIND(&ip_conntrack_hash[hash],
69.                conntrack_tuple_cmp,
71.                struct ip_conntrack_tuple_hash *,
73.                &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple, NULL)
75.         && !LIST_FIND(&ip_conntrack_hash[repl_hash],
77.               conntrack_tuple_cmp,
79.               struct ip_conntrack_tuple_hash *,
81.               &ct->tuplehash[IP_CT_DIR_REPLY].tuple, NULL)) {
83.         /* Remove from unconfirmed list */
85.         list_del(&ct->tuplehash[IP_CT_DIR_ORIGINAL].list);
87.       //将正反方向的TUPLE都加入全局跟踪表中
89.         list_prepend(&ip_conntrack_hash[hash],
91.                  &ct->tuplehash[IP_CT_DIR_ORIGINAL]);
93.         list_prepend(&ip_conntrack_hash[repl_hash],
95.                  &ct->tuplehash[IP_CT_DIR_REPLY]);
97.         /* Timer relative to confirmation time, not original
99.            setting time, otherwise we'd get timer wrap in
101.            weird delay cases. */
103.         ct->timeout.expires += jiffies;
105.         add_timer(&ct->timeout);
107.         atomic_inc(&ct->ct_general.use);
109.         set_bit(IPS_CONFIRMED_BIT, &ct->status);
111.         WRITE_UNLOCK(&ip_conntrack_lock);
113.         return NF_ACCEPT;
115.     }
119.     WRITE_UNLOCK(&ip_conntrack_lock);
121.     return NF_DROP;
123. }