博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
tcp/ip源代码(17)——ip_fragment
阅读量：6228 次
发布时间：2019-06-21

本文共 6702 字，大约阅读时间需要 22 分钟。

作者：gfree.wind@gmail.com
博客：linuxfocus.blog.chinaunix.net
今天学习上次剩下的最后一个UDP 发送数据调用中的最后一个函数，ip_fragment。这个函数用于当IP数据包过大时，对其进行分片发送。
  1. /*
  2.  *    This IP datagram is too large to be sent in one piece. Break it up into
  3.  *    smaller pieces (each of size equal to IP header plus
  4.  *    a block of the data of the original IP data part) that will yet fit in a
  5.  *    single device frame, and queue such a frame for sending.
  6.  */
  8. int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
  9. {
  10.     struct iphdr *iph;
  11.     int ptr;
  12.     struct net_device *dev;
  13.     struct sk_buff *skb2;
  14.     unsigned int mtu, hlen, left, len, ll_rs;
  15.     int offset;
  16.     __be16 not_last_frag;
  17.     struct rtable *rt = skb_rtable(skb);
  18.     int err = 0;
  20.     dev = rt->dst.dev;
  22.     /*
  23.      *    Point into the IP datagram header.
  24.      */
  25.     /* 得到IP报文头的指针 */
  26.     iph = ip_hdr(skb);
  28.     if (unlikely((iph->frag_off & htons(IP_DF)) && !skb->local_df)) {
  29.         /* 禁止分片，增加错误计数 */
  30.         IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
  31.         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
  32.              htonl(ip_skb_dst_mtu(skb)));
  33.         kfree_skb(skb);
  34.         return -EMSGSIZE;
  35.     }
  37.     /*
  38.      *    Setup starting values.
  39.      */
     /* 得到IP报文总长度 */
  1.     hlen = iph->ihl * 4;
  2.     /* 这里的mtu为真正的MTU-IP报文头，即允许的最大IP数据长度 */
  3.     mtu = dst_mtu(&rt->dst) - hlen;    /* Size of data space */
  4. #ifdef CONFIG_BRIDGE_NETFILTER
  5.     if (skb->nf_bridge)
  6.         mtu -= nf_bridge_mtu_reduction(skb);
  7. #endif
  8.     /* 为这个skb_buff置上分片完成的标志 */
  9.     IPCB(skb)->flags |= IPSKB_FRAG_COMPLETE;
  11.     /* When frag_list is given, use it. First, check its validity:
  12.      * some transformers could create wrong frag_list or break existing
  13.      * one, it is not prohibited. In this case fall back to copying.
  14.      *
  15.      * LATER: this step can be merged to real generation of fragments,
  16.      * we can switch to copy when see the first bad fragment.
  17.      */
  18.     /* 根据前面的学习，我们知道4层有可能会将数据包分片。这些分片存放在skb的frag_list中*/
  19.     if (skb_has_frags(skb)) {
  20.         /* skb_buffer已经有了一个frag list */
  21.         struct sk_buff *frag, *frag2;
  22.         /* 拿到数据包的长度 */
  23.         int first_len = skb_pagelen(skb);
         /*
         1.数据包的长度超过了MTU；
         2.数据包长度没有按8字节对齐；
         3.数据包设置了IP_MF或者IP_OFFSET位
         这样，进入slow_path
         */
  1.         if (first_len - hlen > mtu ||
  2.          ((first_len - hlen) & 7) ||
  3.          (iph->frag_off & htons(IP_MF|IP_OFFSET)) ||
  4.          skb_cloned(skb))
  5.             goto slow_path; //跳到slow_path
         /* 遍历每一个分片 */
  1.         skb_walk_frags(skb, frag) {
  2.             /* 检查每个分片，如果有一个分片不符合要求，就只能使用slow path */
  3.             /* Correct geometry. */
  4.             if (frag->len > mtu ||
  5.              ((frag->len & 7) && frag->next) ||
  6.              skb_headroom(frag) hlen)
  7.                 goto slow_path_clean;
  9.             /* Partially cloned skb? */
  10.             if (skb_shared(frag))
  11.                 goto slow_path_clean;
  13.             BUG_ON(frag->sk);
  14.             if (skb->sk) {
  15.                 frag->sk = skb->sk;
  16.                 frag->destructor = sock_wfree;
  17.             }
  18.             skb->truesize -= frag->truesize;
  19.         }
  21.         /* Everything is OK. Generate! */
  22. /* 现在可以进行fast path了*/
  23.         err = 0;
  24.         offset = 0;
  25.         /* 拿到frag list */
  26.         frag = skb_shinfo(skb)->frag_list;
  27.         /* 重置原来的frag list，相当于从skb_buff上取走了frag list */
  28.         skb_frag_list_init(skb);
  29.         /* 
  30.         得到实际的数据长度，置分片标志位和校验和
  31.         */
  32.         skb->data_len = first_len - skb_headlen(skb);
  33.         skb->len = first_len;
  34.         iph->tot_len = htons(first_len);
  35.         iph->frag_off = htons(IP_MF);
  36.         ip_send_check(iph);
         /* 分别处理每一个分片 */
  1.         for (;;) {
  2.             /* Prepare header of the next frame,
  3.              * before previous one went down. */
  4.             if (frag) {
  5.                 /* 表示checksm已经算好*/
  6.                 frag->ip_summed = CHECKSUM_NONE;
  7.                 /* 设置传输层*/
  8.                 skb_reset_transport_header(frag);
  9.                 __skb_push(frag, hlen);
  10.                 /* 设置网络层 */
  11.                 skb_reset_network_header(frag);
  12.                 memcpy(skb_network_header(frag), iph, hlen);
  13.                 iph = ip_hdr(frag);
  14.                 iph->tot_len = htons(frag->len);
  15.                 ip_copy_metadata(frag, skb);
  16.                 if (offset == 0)
  17.                     ip_options_fragment(frag);
  18.                 offset = skb->len - hlen;
  19.                 iph->frag_off = htons(offset>>3);
  20.                 if (frag->next != NULL)
  21.                     iph->frag_off |= htons(IP_MF);
  22.                 /* Ready, complete checksum */
  23. /* 计算分片的校验和 */
  24.                 ip_send_check(iph);
  25.             }
     /* 发送 */
  1.             err = output(skb);
  3.             if (!err)
  4.                 IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);
  5.             if (err || !frag)
  6.                 break;
  8.             skb = frag;
  9.             frag = skb->next;
  10.             skb->next = NULL;
  11.         }
  13.         if (err == 0) {
  14.             IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGOKS);
  15.             return 0;
  16.         }
         /* 出错是否内存 */
  1.         while (frag) {
  2.             skb = frag->next;
  3.             kfree_skb(frag);
  4.             frag = skb;
  5.         }
  6.         IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
  7.         return err;
  9. slow_path_clean:
  10.         /* 清除shared sk_buff */
  11.         skb_walk_frags(skb, frag2) {
  12.             if (frag2 == frag)
  13.                 break;
  14.             frag2->sk = NULL;
  15.             frag2->destructor = NULL;
  16.             skb->truesize = frag2->truesize;
  17.         }
  18.     }
  20. slow_path:
  21.     left = skb->len - hlen;        /* Space per frame */
  22.     ptr = hlen;        /* Where to start from */
  24.     /* for bridged IP traffic encapsulated inside f.e. a vlan header,
  25.      * we need to make room for the encapsulating header
  26.      */
  27.     ll_rs = LL_RESERVED_SPACE_EXTRA(rt->dst.dev, nf_bridge_pad(skb));
  29.     /*
  30.      *    Fragment the datagram.
  31.      */
     /* 得到偏移 */
  1.     offset = (ntohs(iph->frag_off) & IP_OFFSET) 3;
  2.    /* 通过IP_MF标志位，判断是否是最后一个分片 */
  3.     not_last_frag = iph->frag_off & htons(IP_MF);
  5.     /*
  6.      *    Keep copying data until we run out.
  7.      */
  9.     while (left > 0) {
  10.         /* 计算分片长度 */
  11.         len = left;
  12.         /* IF: it doesn't fit, use 'mtu' - the data space left */
  13.         if (len > mtu)
  14.             len = mtu;
  15.         /* IF: we are not sending upto and including the packet end
  16.          then align the next start on an eight byte boundary */
  17.         if (len left)    {
  18.             len &= ~7;
  19.         }
  20.         /*
  21.          *    Allocate buffer.
  22.          */
          /* 为分片申请该分片申请一个sk_buff */
  1.         if ((skb2 = alloc_skb(len hlen ll_rs, GFP_ATOMIC)) == NULL) {
  2.             NETDEBUG(KERN_INFO "IP: frag: no memory for new fragment!\n");
  3.             err = -ENOMEM;
  4.             goto fail;
  5.         }
  7.         /*
  8.          *    Set up data on packet
  9.          */
         /* 复制数据，以及运输层 */
  1.         ip_copy_metadata(skb2, skb);
  2.         skb_reserve(skb2, ll_rs);
  3.         skb_put(skb2, len hlen);
  4.         skb_reset_network_header(skb2);
  5.         skb2->transport_header = skb2->network_header hlen;
  7.         /*
  8.          *    Charge the memory for the fragment to any owner
  9.          *    it might possess
  10.          */
  12.         if (skb->sk)
  13.             skb_set_owner_w(skb2, skb->sk);
  15.         /*
  16.          *    Copy the packet header into the new buffer.
  17.          */
  19.         skb_copy_from_linear_data(skb, skb_network_header(skb2), hlen);
  21.         /*
  22.          *    Copy a block of the IP datagram.
  23.          */
  24.         if (skb_copy_bits(skb, ptr, skb_transport_header(skb2), len))
  25.             BUG();
  26.         left -= len;
  28.         /*
  29.          *    Fill in the new header fields.
  30.          */
  31.         /* 填充网络层 */
  32.         iph = ip_hdr(skb2);
  33.         iph->frag_off = htons((offset >> 3));
  35.         /* ANK: dirty, but effective trick. Upgrade options only if
  36.          * the segment to be fragmented was THE FIRST (otherwise,
  37.          * options are already fixed) and make it ONCE
  38.          * on the initial skb, so that all the following fragments
  39.          * will inherit fixed options.
  40.          */
  41.         /* 如果是第一个分片， 填充ip option */
  42.         if (offset == 0)
  43.             ip_options_fragment(skb);
  45.         /*
  46.          *    Added AC : If we are fragmenting a fragment that's not the
  47.          *         last fragment then keep MF on each bit
  48.          */
  49.         /* 设置IP_MF标志位 */
  50.         if (left > 0 || not_last_frag)
  51.             iph->frag_off |= htons(IP_MF);
  52.         ptr = len;
  53.         offset = len;
  55.         /*
  56.          *    Put this fragment into the sending queue.
  57.          */
  58.         iph->tot_len = htons(len hlen);
 /* 计算校验和 */
  1.         ip_send_check(iph);
 /* 发送该分片 */
  1.         err = output(skb2);
  2.         if (err)
  3.             goto fail;
  5.         IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);
  6.     }
     /* 释放sk_buff */
  1.     kfree_skb(skb);
  2.     IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGOKS);
  3.     return err;
  5. fail:
  6.     kfree_skb(skb);
  7.     IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
  8.     return err;
  9. }
前段时间一直没有大块的时间，每天工作回家比较累，也就懒得看了。周末又陪老婆打球，休息了休息，也没看。今天总算给看完了。

转载地址：http://mwina.baihongyu.com/

你可能感兴趣的文章
Git命令行大全
查看>>
Node.js 4493图片批量下载爬虫1.00
查看>>
其实人缺乏对数据的真实分析能力，只知道数据展现和推演
查看>>
连接H3C交换机的Console口连不上
查看>>
Redis 简介
查看>>
JSt中对象的prototype属性
查看>>
iPhone应用程序 将图片保存到相册实例
查看>>
给DropDownList添加ToolTip(title)属性
查看>>
IOS新特性详情
查看>>
redis性能测试
查看>>
浅谈mysql的两阶段提交协议
查看>>
《影响力》 一个活生生的例子(转载)
查看>>
程序员有趣的面试智力题（转）
查看>>
分布式监控系统Zabbix-3.0.3-完整安装记录（2）-添加mysql监控
查看>>
phpstorm中完成一键快速注释函数头
查看>>
VMware公司SpringSource部门宣布收购Gemstone Systems公司
查看>>
Linux Start Restart and Stop The Cron or Crond Service
查看>>
2014第12周四开发记
查看>>
[转]Spring MVC之@RequestMapping 详解
查看>>
HttpComponents入门解析
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2025-01-08 19:43:18   当前IP: 3.145.41.203   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我