我们都知道数据链路层有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组包的实现还是比较清晰的。