❤工作这么久，分片重组功能你真的研究过吗？❤

声明：未经本人同意，严禁一切形式转载！！！

---

---

本篇文章主要介绍的内容为NF_IP_LOCAL_IN钩子前后的处理逻辑。

1. NF_IP_LOCAL_IN这部分的作用

这部分的主要作用是:接收并处理发往本地的IP报文，由于这里依然属于IP层，处理的逻辑比较简单：

• IP报文分片重组
• 原始套接字相关处理
• 将报文去除头部后，传递给传输层处理

下面会这几个功能做一个简单的介绍。

2. ip_local_deliver接口

该函数的作用：

• IP报文的分片重组，函数接口为：ip_defrag()
• 进入NF_IP_LOCAL_IN HOOK点
• 在HOOK点之后进入ip_local_deliver_finish()

此函数的核心功能便是：传说中的IP报文分片重组。

2.1 分片重组模块~整体框架

2.2 分片重组时数据组织结构

2.3 分片报文重组完毕后的数据结构

2.4 相关函数

分片重组功能涉及的函数有：

函数名称	作用
ip_defrag	分片重组报文核心处理函数，其他相关函数皆在此函数中直接或者间接调用
ip_find	查找分片报文对应的队列头，如果没有找到，则创建一个分片报文队列头部节点(描述信息)
ip_frag_create	根据（sip,dip,id,proto）创建一个分片报文头部节点并插入到队列中
ip_frag_intern	将创建的分片报文头部节点插入到全局分片报文哈希表中
ip_frag_queue	将分片放入插入相应分片队列的合适位置(根据报文中的偏移量进行排序)
ip_frag_reasm	分片报文重组。（不容易理解!!!）
ipq_put	无人引用时，释放分片报文头部节点以及缓存的所有分片报文
ip_frag_destroy	释放分片报文头部节点以及缓存的所有分片报文
ip_evictor	当缓存的分片报文总大小超过设置的阈值时，根据LRU释放一部分缓存的分片报文空间
ipq_kill	设置标记位，声明此节点即将被释放

下面对上表中的几个重要函数做一个说明。可以结合上面的处理逻辑和数组组织结构一起更容易理解。

2.4.1 ip_local_deliver()函数

/*
 * 	Deliver IP Packets to the higher protocol layers.
 */ 
int ip_local_deliver(struct sk_buff *skb)
{
	/*
	 *	Reassemble IP fragments.
	 */

	if (skb->nh.iph->frag_off & htons(IP_MF|IP_OFFSET)) {
		skb = ip_defrag(skb, IP_DEFRAG_LOCAL_DELIVER);/*分片重组之后的报文*/
		if (!skb)
			return 0;
	}

	return NF_HOOK(PF_INET, NF_IP_LOCAL_IN, skb, skb->dev, NULL,
		       ip_local_deliver_finish);
}

2.4.2 ip_defrag()函数

此函数是分片重组的核心函数接口.

struct sk_buff *ip_defrag(struct sk_buff *skb, u32 user)
{
	struct iphdr *iph = skb->nh.iph;
	struct ipq *qp;
	struct net_device *dev;
	
	IP_INC_STATS_BH(IPSTATS_MIB_REASMREQDS);

	/* Start by cleaning up the memory. */
	if (atomic_read(&ip_frag_mem) > sysctl_ipfrag_high_thresh)/*缓存的报文超过系统分片阈值时释放一部分缓存*/
		ip_evictor();

	dev = skb->dev;

	/* Lookup (or create) queue header */
	if ((qp = ip_find(iph, user)) != NULL) {/*查找分片节点，只有出错时才可能为null*/
		struct sk_buff *ret = NULL;

		spin_lock(&qp->lock);

		ip_frag_queue(qp, skb);/*将此分片报文根据序号插入到分片队列中*/

		if (qp->last_in == (FIRST_IN|LAST_IN) &&
		    qp->meat == qp->len)
			ret = ip_frag_reasm(qp, dev);/*分片报文重组*/

		spin_unlock(&qp->lock);
		ipq_put(qp, NULL);/**/
		return ret;
	}

	IP_INC_STATS_BH(IPSTATS_MIB_REASMFAILS);
	kfree_skb(skb);
	return NULL;
}

2.4.3 ip_find()函数

/* Find the correct entry in the "incomplete datagrams" queue for
 * this IP datagram, and create new one, if nothing is found.
 */
static inline struct ipq *ip_find(struct iphdr *iph, u32 user)
{
	__u16 id = iph->id;
	__u32 saddr = iph->saddr;
	__u32 daddr = iph->daddr;
	__u8 protocol = iph->protocol;
	unsigned int hash = ipqhashfn(id, saddr, daddr, protocol);
	struct ipq *qp;

	read_lock(&ipfrag_lock);
	for(qp = ipq_hash[hash]; qp; qp = qp->next) {
		if(qp->id == id		&&
		   qp->saddr == saddr	&&
		   qp->daddr == daddr	&&
		   qp->protocol == protocol &&
		   qp->user == user) {/*已经缓存过此五元组的分片报文，直接返回*/
			atomic_inc(&qp->refcnt);
			read_unlock(&ipfrag_lock);
			return qp;
		}
	}
	read_unlock(&ipfrag_lock);

	return ip_frag_create(hash, iph, user);/*未缓存过此类分片报文，则创建分片缓存*/
}

2.4.4 ip_frag_queue()函数

/* Add new segment to existing queue. */
static void ip_frag_queue(struct ipq *qp, struct sk_buff *skb)/*每一个分片报文一个队列，在队列中根据偏移进行排序*/
{
	struct sk_buff *prev, *next;
	int flags, offset;
	int ihl, end;

	if (qp->last_in & COMPLETE)/*此qp即将被释放*/
		goto err;

 	offset = ntohs(skb->nh.iph->frag_off);
	flags = offset & ~IP_OFFSET;
	offset &= IP_OFFSET;
	offset <<= 3;		/* offset is in 8-byte chunks */
 	ihl = skb->nh.iph->ihl * 4;

	/* Determine the position of this fragment. */
 	end = offset + skb->len - ihl;/*该分片报文在原报文中的起始位置*/

	/* Is this the final fragment? */
	if ((flags & IP_MF) == 0) {/*最后一个分片报文*/
		/* If we already have some bits beyond end
		 * or have different end, the segment is corrrupted.此段已损坏
		 */
		if (end < qp->len ||
		    ((qp->last_in & LAST_IN) && end != qp->len))/*格式检查*/
			goto err;
		qp->last_in |= LAST_IN;/*分片全部收到标记位*/
		qp->len = end;/*所有的分片报文总长度*/
	} else {
		if (end&7) {/*必须是8的倍数??? why*/
			end &= ~7;
			if (skb->ip_summed != CHECKSUM_UNNECESSARY)
				skb->ip_summed = CHECKSUM_NONE;
		}
		if (end > qp->len) {/*qp->len可以当做是一个滑动窗口*/
			/* Some bits beyond end -> corruption. */
			if (qp->last_in & LAST_IN)/*不是最后一个报文*/
				goto err;
			qp->len = end;
		}
	}
	if (end == offset)
		goto err;

	if (pskb_pull(skb, ihl) == NULL)
		goto err;
	if (pskb_trim(skb, end-offset))
		goto err;

	/* Find out which fragments are in front and at the back of us
	 * in the chain of fragments so far.  We must know where to put
	 * this fragment, right?
	 */
	prev = NULL;
	for(next = qp->fragments; next != NULL; next = next->next) {/*为分片报文在队列中找到合适的位置*/
		if (FRAG_CB(next)->offset >= offset)/*1、2、3、4、5、6、8、9*/
			break;	/* bingo! */		/*------------------7-----*/
		prev = next;
	}

	/* We found where to put this one.  Check for overlap with
	 * preceding fragment, and, if needed, align things so that
	 * any overlaps are eliminated.
	 */
	if (prev) {
		int i = (FRAG_CB(prev)->offset + prev->len) - offset;
		/*i<0时说明存在空洞，如何处理呢?*/
		
		if (i > 0) {/*两个分片报文存在重叠部分，则略过偏移部分*/
			offset += i;
			if (end <= offset)
				goto err;
			if (!pskb_pull(skb, i))
				goto err;
			if (skb->ip_summed != CHECKSUM_UNNECESSARY)
				skb->ip_summed = CHECKSUM_NONE;
		}
	}

	while (next && FRAG_CB(next)->offset < end) {/*当前报文与后一个分片报文有重叠部分*/
		int i = end - FRAG_CB(next)->offset; /* overlap is 'i' bytes *//*重叠部分大小*/

		if (i < next->len) {
			/* Eat head of the next overlapped fragment
			 * and leave the loop. The next ones cannot overlap.
			 */
			if (!pskb_pull(next, i))/*从已收到的分片报文中去掉重复的部分*/
				goto err;
			FRAG_CB(next)->offset += i;
			qp->meat -= i;
			if (next->ip_summed != CHECKSUM_UNNECESSARY)
				next->ip_summed = CHECKSUM_NONE;
			break;
		} else {/*重复收到同一个分片报文/或者比已收到的报文大，使用新报文替代旧报文，释放旧报文空间*/
			struct sk_buff *free_it = next;

			/* Old fragmnet is completely overridden with
			 * new one drop it.
			 */
			next = next->next;

			if (prev)
				prev->next = next;
			else
				qp->fragments = next;

			qp->meat -= free_it->len;
			frag_kfree_skb(free_it, NULL);
		}
	}

	FRAG_CB(skb)->offset = offset;

	/* Insert this fragment in the chain of fragments. */
	skb->next = next;
	if (prev)
		prev->next = skb;
	else
		qp->fragments = skb;

 	if (skb->dev)
 		qp->iif = skb->dev->ifindex;
	skb->dev = NULL;
	qp->stamp = skb->stamp;/*更新时间戳*/
	qp->meat += skb->len;
	atomic_add(skb->truesize, &ip_frag_mem);
	if (offset == 0)
		qp->last_in |= FIRST_IN;

	write_lock(&ipfrag_lock);
	list_move_tail(&qp->lru_list, &ipq_lru_list);/*维护LRU队列，将该节点移到末尾*/
	write_unlock(&ipfrag_lock);

	return;

err:
	kfree_skb(skb);
}

2.4.5 ip_frag_reasm()函数

/* Build a new IP datagram from all its fragments. */
/*分片报文重组*/
/*
*需要特别说明的是:这个函数并没有直接将多个分片报文重组成一个大报文
*而是利用了
*/
static struct sk_buff *ip_frag_reasm(struct ipq *qp, struct net_device *dev)
{
	struct iphdr *iph;
	struct sk_buff *fp, *head = qp->fragments;
	int len;
	int ihlen;

	ipq_kill(qp);/*设置标记位，表明此分片报文空间即将被释放(无需区分空间不足还是接收完毕)*/

	BUG_TRAP(head != NULL);
	BUG_TRAP(FRAG_CB(head)->offset == 0);

	/* Allocate a new buffer for the datagram. */
	ihlen = head->nh.iph->ihl*4;
	len = ihlen + qp->len;/*分片报文总长度+一个IP头部长度*/

	if(len > 65535)/*报文最长为65535*/
		goto out_oversize;

	/* Head of list must not be cloned. */
	if (skb_cloned(head) && pskb_expand_head(head, 0, 0, GFP_ATOMIC))
		goto out_nomem;

	/* If the first fragment is fragmented itself, we split
	 * it to two chunks: the first with data and paged part
	 * and the second, holding only fragments. */
	if (skb_shinfo(head)->frag_list) {/*如果第一个分片报文的skb不是连续的，需要特别处理*/
		struct sk_buff *clone;
		int i, plen = 0;

		if ((clone = alloc_skb(0, GFP_ATOMIC)) == NULL)
			goto out_nomem;
		clone->next = head->next;
		head->next = clone;
		skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
		skb_shinfo(head)->frag_list = NULL;
		for (i=0; i<skb_shinfo(head)->nr_frags; i++)
			plen += skb_shinfo(head)->frags[i].size;
		clone->len = clone->data_len = head->data_len - plen;
		head->data_len -= clone->len;
		head->len -= clone->len;
		clone->csum = 0;
		clone->ip_summed = head->ip_summed;
		atomic_add(clone->truesize, &ip_frag_mem);
	}

	skb_shinfo(head)->frag_list = head->next;
	skb_push(head, head->data - head->nh.raw);
	atomic_sub(head->truesize, &ip_frag_mem);

	for (fp=head->next; fp; fp = fp->next) {/*统计报文长度*/
		head->data_len += fp->len;
		head->len += fp->len;
		if (head->ip_summed != fp->ip_summed)
			head->ip_summed = CHECKSUM_NONE;
		else if (head->ip_summed == CHECKSUM_HW)
			head->csum = csum_add(head->csum, fp->csum);
		head->truesize += fp->truesize;
		atomic_sub(fp->truesize, &ip_frag_mem);
	}

	head->next = NULL;
	head->dev = dev;
	head->stamp = qp->stamp;/*时间戳,为最后一个报文的时间戳*/

	iph = head->nh.iph;
	iph->frag_off = 0;
	iph->tot_len = htons(len);
	IP_INC_STATS_BH(IPSTATS_MIB_REASMOKS);
	qp->fragments = NULL;/*这里指针已经释放了!!!!!!也就是说分片重组的报文在这里并没有被释放，而是在其他地方释放*/
	return head;

out_nomem:
 	NETDEBUG(if (net_ratelimit())
	         printk(KERN_ERR 
			"IP: queue_glue: no memory for gluing queue %p\n",
			qp));
	goto out_fail;
out_oversize:
	if (net_ratelimit())
		printk(KERN_INFO
			"Oversized IP packet from %d.%d.%d.%d.\n",
			NIPQUAD(qp->saddr));
out_fail:
	IP_INC_STATS_BH(IPSTATS_MIB_REASMFAILS);
	return NULL;
}

3. ip_local_deliver_finish接口

此函数的主要作用包括：

• IP层报文即将交由传输层进行处理，因此先将IP头部去除；
• 检查是否存在原始套接字监控此协议报文，如果有，则复制一份skb,交由所有监控此协议的原始套接字(交给原始套接字处理前需要再添加上IP头部)；
• 传递给相应的传输层协议进行后续处理；

如果不考虑传输层报文解析处理，则涉及的函数比较少；其中比较多的就是原始套接字相关的函数接口，这部分尚未整理学习，这里不再详细说明。我们只需要知道的是：在这里有一个原始套接字处理的过程即可。

3.1 实现逻辑

• 关于“为什么在传输层不支持此协议时，需要再次判断是否有原始套接字监控？？而只有在没有被监听的情况下才能提示“协议不可达”呢？？？”

就目前我所知道的而言，有一部分报文不需要无法通过监听固定端口来接收报文，如OSPF协议的hello报文，没有对应的传输层端口。处理这类报文的方式通常是：在应用层通过原始套接字进行获取，因此这里在处理时有这么一个逻辑也就在情理之中了；毕竟该报文已经被正确的接收，只不过接收的对象比较特殊而已，因此这种情况也不能提示“协议不可达”。

3.1 相关函数

这里只介绍ip_local_deliver_finish()函数。

3.1.1 ip_local_deliver_finish()

static inline int ip_local_deliver_finish(struct sk_buff *skb)/*分片重组后的报文*/
{
	int ihl = skb->nh.iph->ihl*4;

#ifdef CONFIG_NETFILTER_DEBUG
	nf_debug_ip_local_deliver(skb);
#endif /*CONFIG_NETFILTER_DEBUG*/

	__skb_pull(skb, ihl);/*去ip头*/

	/* Free reference early: we don't need it any more, and it may
           hold ip_conntrack module loaded indefinitely. */
	nf_reset(skb);

        /* Point into the IP datagram, just past the header. */
        skb->h.raw = skb->data;/*IP数据部分*/

	rcu_read_lock();
	{
		/* Note: See raw.c and net/raw.h, RAWV4_HTABLE_SIZE==MAX_INET_PROTOS */
		int protocol = skb->nh.iph->protocol;/*获取四层协议*/
		int hash;
		struct sock *raw_sk;
		struct net_protocol *ipprot;

	resubmit:
		hash = protocol & (MAX_INET_PROTOS - 1);/*以协议作为hash检索原始套接字和传输层处理接口*/
		raw_sk = sk_head(&raw_v4_htable[hash]);/*获取原始套接字链表中的第一个sock结构*/

		/* If there maybe a raw socket we must check - if not we
		 * don't care less
		 */
		if (raw_sk)/*有原始套接字在监控此协议报文，则复制一份skb给原始套接字*/
			raw_v4_input(skb, skb->nh.iph, hash);

		
		if ((ipprot = rcu_dereference(inet_protos[hash])) != NULL) {/*获取传输层协议操作结构体*/
			int ret;

			if (!ipprot->no_policy &&
			    !xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
				kfree_skb(skb);
				goto out;
			}
			/*交由传输层继续处理此报文，注意这里ip头部已经去除*/
			ret = ipprot->handler(skb);/*常见的有UDP,TCP, ICMP,ESP, AH, IGMP, ... ...*/
			if (ret < 0) {
				protocol = -ret;
				goto resubmit;
			}
			IP_INC_STATS_BH(IPSTATS_MIB_INDELIVERS);
		} else {
			/*这里为何在没有原始套接字时才提示不可达呢?
			*因为有一部分报文只能通过原始套接字接收，如ospf协议的hello报文，没有接收接口信息
			*有的直接通过原始套接字将hello报文抓取到应用层进行处理。这里应该处理的是这种情况!!!
			**/
			if (!raw_sk) {/*此协议不识别，又无原始套接字在监控，返回协议不可达(好像是协议不可达)*/
				if (xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
					IP_INC_STATS_BH(IPSTATS_MIB_INUNKNOWNPROTOS);
					icmp_send(skb, ICMP_DEST_UNREACH,
						  ICMP_PROT_UNREACH, 0);
				}
			} else
				IP_INC_STATS_BH(IPSTATS_MIB_INDELIVERS);
			kfree_skb(skb);
		}
	}
 out:
	rcu_read_unlock();

	return 0;
}