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

// 创建一个队列用于重组分片，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);
}

// 根据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);
}

// 创建一个表示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);
}

// 判断分片是否全部到达
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);
}

// 重组成功后构造完整的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);
}

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;

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;
        }
    }

    // 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 = 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;   
    }

    // 处理当前节点和后面节点的重叠问题
    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);
    }