深入理解TCP/IP协议的实现之ip分片重组（基于linux1.2.13）

我们都知道数据链路层有mtu的限制，如果我们上层发的包太大，那就要分片，那么对端就需要重组分片，组装好再通知上层。我们看一下分片重组的过程。我们看一下分片重组中用到的数据结构。ipq结构体是代表一个完整的传输层包，他被ip层分成了多个分片。ipfrag结构体是代表一个ip分片。他是传输层包的一个部分。

再看一下ip报文的格式。

我们开始分析组片之前，先看一下一些基础函数。
1 创建一个用于重组传输层数据包的结构体ipq。这个是第一个ip分配到达时调用的。他维护了属于同一个分片组（同一个传输层数据包）的多个分片。

// 创建一个队列用于重组分片，iphdr 即ip报文头
static struct ipq *ip_create(struct sk_buff *skb, struct iphdr *iph, struct device *dev)
{
	struct ipq *qp;
	int maclen;
	int ihlen;
	// 申请一个新ipq的表示分片队列
	qp = (struct ipq *) kmalloc(sizeof(struct ipq), GFP_ATOMIC);
	// 初始化内存
	memset(qp, 0, sizeof(struct ipq));
	
	// skb->data指向mac头首地址，mac头长度等于ip头减去mac头首地址
	maclen = ((unsigned long) iph) - ((unsigned long) skb->data);
	// 分配内存保存mac头
	qp->mac = (unsigned char *) kmalloc(maclen, GFP_ATOMIC);

	// ip头长度由ip头字段*4得出，多分配8个字节给icmp
	ihlen = (iph->ihl * sizeof(unsigned long));
	qp->iph = (struct iphdr *) kmalloc(ihlen + 8, GFP_ATOMIC);

	// 把mac头内容复制到mac字段
	memcpy(qp->mac, skb->data, maclen);
	// 把ip头和传输层的8个字节复制到iph字段，8个字段的内容用于发送icmp报文时
	memcpy(qp->iph, iph, ihlen + 8);
	
	// 未分片的ip报文的总长度，未知，收到所有分片后重新赋值
	qp->len = 0;
	// 当前分片的ip头和mac头长度
	qp->ihlen = ihlen;
	qp->maclen = maclen;
	qp->fragments = NULL;
	// 关联的设备
	qp->dev = dev;
	// 开始计时，一定时间内还没收到所有分片则重组失败，发送icmp报文
	qp->timer.expires = IP_FRAG_TIME;		
	qp->timer.data = (unsigned long) qp;		
	qp->timer.function = ip_expire;		
	// 开始计时，如果超时没有收到新的ip分片，则重组失败，如果收到一个新的，重置计时器
	add_timer(&qp->timer);
	
	qp->prev = NULL;
	cli();
	// 头插法插入分片重组的队列
	qp->next = ipqueue;
	/*
		如果当前新增的节点不是第一个节点则把当前第一个
		节点的prev指针指向新增的节点
	*/
	if (qp->next != NULL)
		qp->next->prev = qp;
	//更新ipqueue指向新增的节点，新增节点是首节点 
	ipqueue = qp;
	
	sti();
	return(qp);
}

根据一开始的结构体，上面的代码不难理解。主要是申请一个ipq结构体。然后初始化各个字段，最后插入ipq队列。并且开始计算分片重组的超时时间和超时回调。

2 通过ip头查找对应的ipq队列。

// 根据ip头找到分片队列的头指针
static struct ipq *ip_find(struct iphdr *iph)
{
	struct ipq *qp;
	struct ipq *qplast;

	cli();
	qplast = NULL;
	// ipqueue类似一个全局头指针
	for(qp = ipqueue; qp != NULL; qplast = qp, qp = qp->next)
	{	// 对比ip头里的几个字段，id是标记报文属于同一个传输层原始包的
		if (iph->id== qp->iph->id && 
			iph->saddr == qp->iph->saddr &&
			iph->daddr == qp->iph->daddr && 
			iph->protocol == qp->iph->protocol
		)
		{	// 找到后重置计时器，重新计算重组的超时时间，即每次新分片到来，重新计算超时时间
			del_timer(&qp->timer);	
			sti();
			return(qp);
		}
	}
	sti();
	return(NULL);
}

3 创建一个表示单个ip分片的结构体ipfrag 。他表示其中一个分片。

// 创建一个表示ip分片的结构体
static struct ipfrag *ip_frag_create(int offset, int end, struct sk_buff *skb, unsigned char *ptr)
{
	struct ipfrag *fp;

	fp = (struct ipfrag *) kmalloc(sizeof(struct ipfrag), GFP_ATOMIC);
	memset(fp, 0, sizeof(struct ipfrag));
	// ip分配的首字节在未分片数据（分片前的数据包）中的偏移
	fp->offset = offset; 
	// 最后一个字节的偏移 + 1，即下一个分片的首字节偏移
	fp->end = end; 
	// 分片长度，即数据长度
	fp->len = end - offset; 
	fp->skb = skb;
	// 指向分片的数据首地址
	fp->ptr = ptr; 
	return(fp);
}

4 判断分片是否已经全部到达。

// 判断分片是否全部到达
static int ip_done(struct ipq *qp)
{
	struct ipfrag *fp;
	int offset;
	/*
		收到最后分片的时候才会更新len字段，如果没有收到他就是初始化0，
		所以为0说明最后一个分片还没到达，直接返回未完成
	*/
	if (qp->len == 0)
		return(0);
	// 走到这里说明全部分片已经到达,fragments指向所有分片队列的首节点
	fp = qp->fragments;
	offset = 0;
	/*
	 检查所有分片，每个分片按照偏移从小到大(从链表头到尾)排序的链表
	，因为每次分片节点到达时会插入相应的位置
	*/
	while (fp != NULL)
	{	/*
			如果当前节点的偏移大于期待的偏移(即上一个节点的最后一个
			字节的偏移+1，由end字段表示)，说明有中间节点没到达，直
			接返回未完成
		*/
		if (fp->offset > offset)
			return(0);	
		// 下一个期待的偏移
		offset = fp->end;
		fp = fp->next;
	}

	// 分片全部到达并且每个分片的字节连续则重组完成
	return(1);
}

5 重组同一队列里的所有ip分片。

// 重组成功后构造完整的ip报文
static struct sk_buff *ip_glue(struct ipq *qp)
{
	struct sk_buff *skb;
	struct iphdr *iph;
	struct ipfrag *fp;
	unsigned char *ptr;
	int count, len;

	// 重组后整个包的长度等于mac头长度+ip头长度+数据长度
	len = qp->maclen + qp->ihlen + qp->len;
	// 分配新的skb，skb->data指向len大小的内存	
	if ((skb = alloc_skb(len,GFP_ATOMIC)) == NULL)
	{
		ip_free(qp);
		return(NULL);
	}
	// ip头+数据的长度，多个分片中，每个分片都有ip头，重组后只有一个ip头。和数据部分
	skb->len = (len - qp->maclen);
	// skb->h.raw和skb->data字段指向新分配的内存首地址（alloc_skb分配的）
	skb->h.raw = skb->data; 
	skb->free = 1;
	
	// 指向alloc_skb中分配的新内存，开始组包，先拼接mac头和ip头
	ptr = (unsigned char *) skb->h.raw;
	// 把mac头复制到新的内存
	memcpy(ptr, ((unsigned char *) qp->mac), qp->maclen); 
	// 指向ip头的首地址
	ptr += qp->maclen;
	// 把ip头复制到新的内存
	memcpy(ptr, ((unsigned char *) qp->iph), qp->ihlen); 
	// 指向数据部分的首地址
	ptr += qp->ihlen; 
	
	skb->h.raw += qp->maclen;// 跨过mac头，指向ip头首地址

	// 当前复制的数据长度
	count = 0;
	// 指向ip分片队列的首节点
	fp = qp->fragments;
	// 开始复制数据部分
	while(fp != NULL)
	{	/*
			 skb->len表示重组后的长度。
			 count表示已经复制的数据长度，不包括ip头长度
			 fp->len表示当前ip分片的数据部分长度
			 如果当前节点的数据长度+已经复制的内容长度大于skb->len
			 则说明内容溢出了，丢弃该数据包
		*/
		if(count+fp->len > skb->len)
		{
			ip_free(qp);
			kfree_skb(skb,FREE_WRITE);
			return NULL;
		}
		// 把分片中的数据复制到对应偏移的位置 
		memcpy((ptr + fp->offset), fp->ptr, fp->len);
		// 已复制的数据长度
		count += fp->len;
		fp = fp->next;
	}

	ip_free(qp);// 数据复制完后可以释放分片队列了
	iph = skb->h.iph; // 上面的raw字段指向了ip头首地址，skb->h.iph等价于raw字段的值
	iph->frag_off = 0; // 清除分片字段
	// 更新ip头中的总长度为ip头+数据的长度
	iph->tot_len = htons((iph->ihl * sizeof(unsigned long)) + count);
	skb->ip_hdr = iph;
	return(skb);
}

重组的大致流程就是申请一块新内存，然后把mac头、ip头复制过去。再遍历分片队列，把每个分片的数据拼起来。最后更新一些字段。
    好了，我们熟悉了ip分片中需要用到的各种基本操作函数。接下来我们从整体来看看，整个组包的过程。由ip_defrag函数处理。因为非常长。我们分段分析。下面是函数定义和一些变量。

static struct sk_buff *ip_defrag(
	struct iphdr *iph, 
	struct sk_buff *skb, 
	struct device *dev
)

	struct ipfrag *prev, *next;
	struct ipfrag *tfp;
	struct ipq *qp;
	struct sk_buff *skb2;
	unsigned char *ptr;
	int flags, offset;
	int i, ihl, end;

首先做一些判断，包括
1 根据ip头找是否已经存在分片队列
2 取得分片的真实偏移（即在没有分片的数据中的偏移）、分片标记。

qp = ip_find(iph); 
offset = ntohs(iph->frag_off);
flags = offset & ~IP_OFFSET; // 取得三个分片标记位
offset &= IP_OFFSET; // 取得分片偏移
// 如果没有更多分片了，并且offset=0（第一个分片），则属于出错，第一个分片后面肯定还有分片，否则干嘛要分片
if (((flags & IP_MF) == 0) && (offset == 0))
{
	if (qp != NULL)
		ip_free(qp);	
	return(skb);
}
// 偏移乘以8得到数据的真实偏移
offset <<= 3;

如果是第一个分片到达。则需要创建一个队列去维护陆续到来的分片。如果不是第一个分片，则重置计时器。

	/*
		如果已经存在分片队列，说明之前已经有分片到达，
		即开启了定时器，所以需要重置计时器，重新计时，超时的逻辑是，
		如果IP_FRAG_TIME时间内没有分片到达，
		则认为重组超时，这里没有以一个绝对大小的总时间来判断。
	*/
	if (qp != NULL)
	{
		del_timer(&qp->timer);
		qp->timer.expires = IP_FRAG_TIME;	
		qp->timer.data = (unsigned long) qp;	
		qp->timer.function = ip_expire;		
		add_timer(&qp->timer);
	}
	else
	{
		// 新建一个管理分片队列的节点
		if ((qp = ip_create(skb, iph, dev)) == NULL)
		{
			skb->sk = NULL;
			kfree_skb(skb, FREE_READ);
			return NULL;
		}
	}

接着看下面代码
1 取得当前ip分片的ip头大小。
2 tot_len是ip报文的长度。减去ip头长度，得到分片中的数据长度。加上偏移得到末位置。
3 skb->data是mac头首地址，加上mac头长度得到ip头首地址
4 判断是不是最后一个分片了，这个根据ip头的标记可以得到。如果是，记录整个ip原始包的总长度。即由最后一个分片的数据计算出来。

	// ip头长度
	ihl = (iph->ihl * sizeof(unsigned long));
	// 偏移+数据部分长度等于end，end的值是最后一个字节+1
	end = offset + ntohs(iph->tot_len) - ihl;
	// data指向整个报文首地址，即mac头首地址，ptr指向ip报文的数据部分
	ptr = skb->data + dev->hard_header_len + ihl;
	/*
		是否是最后一个分片，是的话，未分片的ip报文长度为end，
		即最后一个报文的最后一个字节的偏移+1，因为偏移从0算起
	*/
	if ((flags & IP_MF) == 0)
		qp->len = end;

找到当前分片的位置，从队列的头到尾按偏移从小到大排序。prev指针指向待插入分片的 前一个分片。一会需要用。

	prev = NULL;
	// 插入分片队列相应的位置，保证分片的有序
	for(next = qp->fragments; next != NULL; next = next->next)
	{	// 找出第一个比当前分片偏移大的节点
		if (next->offset > offset)
			break;	/* bingo! */
		prev = next;
	}

处理分片重叠问题。

	/*
		处理当前节点和前面节点的重叠问题，
		1 prev 为空，说明当前就一个分片，不存在重叠情况
		2 prev非空，保证了offset >= prev->offset，
		所以只需要比较当前节点的偏移offset和prev->end字段
	*/
	if (prev != NULL && offset < prev->end)
	{	
		/*
			说明存在重叠，算出重叠的大小，把当前节点的重叠部分丢弃，
			更新offset和ptr指针往前走,没处理完全重叠的情况
		*/
		// 重叠的数据大小
		i = prev->end - offset;
		// 把当前分片的数据丢掉i个字节。指针也向后移动i个字节。
		offset += i;	
		ptr += i;	
	}

处理完了当前节点和前面节点的重叠问题。还需要处理和后面节点的问题。next是待插入节点的后面一个节点。为第一个需要处理的节点。end是待插入分片的末位置。

	// 处理当前节点和后面节点的重叠问题
	for(; next != NULL; next = tfp)
	{	
		// 指向下一个待处理的节点
		tfp = next->next;
		
		// 当前节点及其后面的节点都不会发生重叠了
		if (next->offset >= end)
			break;	
			
		// 反之发生了重叠，算出重叠大小
		i = end - next->offset;			
		// 更新和，当前节点，重叠的节点的字段，往后挪
		next->len -= i;			
		next->offset += i;	
		next->ptr += i;

		// 发生了完全重叠，则删除旧的节点
		if (next->len <= 0)
		{
			if (next->prev != NULL)
				next->prev->next = next->next;// 说明节点不是第一个节点
			else
				qp->fragments = next->next;//  说明节点是第一个节点
			// 这里应该是tfp !=NULL
			if (tfp->next != NULL)
				next->next->prev = next->prev;
			kfree_skb(next->skb,FREE_READ);
			kfree_s(next, sizeof(struct ipfrag));
		}
	}

算出了插入位置，也处理了重叠情况，可以插入队列了。

	tfp = NULL;
	// 创建一个分片节点
	tfp = ip_frag_create(offset, end, skb, ptr);
	// 插入分片队列
	tfp->prev = prev;
	tfp->next = next;
	if (prev != NULL)
		prev->next = tfp;
	else
		qp->fragments = tfp;

	if (next != NULL)
		next->prev = tfp;

最后判断是不是分片已经到齐了。

	// 判断全部分片是否到达，是的话重组
	if (ip_done(qp))
	{
		skb2 = ip_glue(qp);		/* glue together the fragments */
		return(skb2);
	}

整个ip组包的分析完了，看起来代码很多。但是对着结构体，多读几遍，思考一下，其实ip组包的实现还是比较清晰的。