tcp mss clamp while pppoe-凯发app官方网站

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心

苦海澜石

凯发app官方网站首页　| 　博文目录　| 　关于我

khls27

  • 博客访问： 752978
  • 博文数量： 144
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1150
  • 用 户 组： 普通用户
  • 注册时间： 2014-03-17 14:32
个人简介

小公司研发总监，既当司令也当兵！

文章分类

全部博文（144）

推荐博文
相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
tcp mss clamp while pppoe

分类： linux

2016-12-26 23:25:19

背景

网络程序员对于“最大传输单元”--mtu应该都不陌生。对于网络传输而已，一条链路上的负载大小通常都是有限制的。比如，对于以太网，mtu通常被设置为1500字节（ip报文最大长度）。对于网络传输中最常用tcp协议而言，其架设与ip协议之上：tcp是基于流，它的数据需要通过划分成一个一个的块，然后组装成一个一个tcp报文，再交由ip协议封装、并发送。通常，为了更好的使用效率，tcp最好确认其数据块的大小，使得一个tcp报文能够顺利的装入一个ip报文中，而且不超过mtu的限制（相反，如果tcp报文过大，那么在ip层发送时，需要将报文分割为更小的多个报文发送，在接收端重组，效率很低）。tcp为了很好的完成这个任务，其通过扩展选项，通过服务端和客户端进行友好协商，选择一个合适的分片大小（mss），保证双方在数据传输过程中，不需要进行ip分片。

经过上面tcp协商处理后，通常是没有问题的。但后来运营商在网络接入时引入了pppoe后，情况就不同了！

pppoe协议是架设在以太网的ppp协议，它会在ip与ethernet之间添加一个pppoe头部（包含pppoe头部和ppp头部，共8字节），这样其实变形减小了链路的mtu；但问题在于，对于tcp/ip层面而已，pppoe是不可见，即tcp在协商mss时，所看到的mtu依然是ethernet的mtu，并没有排除pppoe头部长度。
见下面一个典型拓扑，client 通过pppoe接入intenet，并试图访问站点server的资源：
（clinet）-------（pppoe cli) ------- (pppoe serv) ------(internet) ------(server)

step1：client向server端发起tcp连接请求，同时申明它支持的最大分片长度为1460字节（mtu - tcp_header_len - ip_header_len）；
step2：server回复client，同时申明自己支持最大分片长度为1460字节；
step3：client发起读取资源请求；
step4-1：server把资源按最大1460字节切片，然封装为tcp报文，进一步封装ip报文，经以太网成帧后发往client。
step4-2：报文从server向client过程中，流经pppoe serv，pppoe serv需要向报文添加pppoe头部，此时发现添加pppoe头部后报文超过mtu限制了！（怎么办？怎么办？怎么办？）
step4-3: （i）server在发送报文时，明确这个报文不允许分片，那么pppoe serv只能丢弃该报文；（ii）pppoe serv检查报文已经超长，那么久默默丢弃，当什么事情也没发生；（iii）pppoe serv对报文进行分片，逐个发生到clinet。

从上面可以看到，当pppoe serv接受到一个“超长”报文时，其对待的态度是不一定的；同理，当client发生一个“超长”报文时，pppoe cli对待态度也是不一定的。很遗憾，绝大多数pppoe cli不会对报文进行分片，并且pppoe serv也不是总是会执行分片操作。由此引发的问题是，通常client可以和server建立连接，但进行大数据传输时却失败了！

凯发app官方网站的解决方案

问题原因知悉后，解决就不困难了。在上述拓扑中，pppoe cli （或者pppoe serv）监听连接过程，client与server进行mss协商时，主动参与，修正mss：
（clinet）-------（pppoe cli) ------- (pppoe serv) ------(internet) ------(server)

step1：client向server端发起tcp连接请求，同时申明它支持的最大分片长度为1460字节；
step1-1：pppoe cli 捕获tcp mss协商，修正为1412字节；
step2：server确认连接请求，知悉client最大支持1412字节；申明其支持1412字节没有问题；
step2-1:pppoe cli 捕获tcp mss 协商，判断其值不大于1412，ok没有问题
step2-2:client 了解到server最大支持1412字节的分片长度；
step3：client请求资源；
step4：server按最大1412字节分片资源，组装发生给client；
step5：client 收到报文，与以ack确认;
......

经过上面分步说明，这个问题基本阐释清楚了。在路由器上，如果采用pppoe接入，通常需要执行tcp mss clamp，下面是内核pppoe模块添加tcp mss clamp的代码：

点击(此处)折叠或打开

  1. static uint16_t tcp_checksum(uint8_t *piphdr, uint8_t *ptcphdr)
  2. {
  3.     uint32_t sum = 0;
  4.     uint16_t count;
  5.     uint16_t tmp;

  7.     uint8_t *addr;
  8.     uint8_t pseudo_header[12];
  9.     int i;

  11.     /* count number of bytes in tcp header and data: ip total length - ip header length */
  12.     count = piphdr[2] * 256 piphdr[3];
  13.     count -= (piphdr[0] & 0x0f) * 4;

  15.     /*ip src addr, dest addr, protocl, payload length*/
  16.     memcpy(pseudo_header, piphdr12, 8);
  17.     pseudo_header[8] = 0;
  18.     pseudo_header[9] = piphdr[9];
  19.     pseudo_header[10] = (count >> 8) & 0xff;
  20.     pseudo_header[11] = (count & 0xff);

  22.     /* checksum the pseudo-header */
  23.     for (i = 0; i < 12; i = 2)
  24.     {
  25.         sum = *(uint16_t *)(pseudo_header i);
  26.     }

  28.     /* checksum the tcp header and data */
  29.     addr = ptcphdr;
  30.     while (count > 1)
  31.     {
  32.         memcpy(&tmp, addr, sizeof(tmp));
  33.         sum = (uint32_t) tmp;
  34.         addr = sizeof(tmp);
  35.         count -= sizeof(tmp);
  36.     }

  38.     if (count > 0)
  39.     {
  40.         sum = (uint8_t) *addr;
  41.     }

  43.     while (sum >> 16)
  44.     {
  45.         sum = (sum & 0xffff) (sum >> 16);
  46.     }
  47.     return (uint16_t) ((~sum) & 0xffff);
  48. }



  52. /**
  53. * detect syn of tcp, clamp msss
  54. */
  55. static void clamp_mss(struct sk_buff* skb, int clamp_mss)
  56. {
  57.     struct tcphdr* ptcphdr;
  58.     struct iphdr* piphdr;
  59.     uint8_t* pppphdr;
  60.     struct pppoe_hdr *ppppoehdr;
  61.     int len;
  62.     int minlen;
  63.     int optlen;

  65.     uint16_t csum;
  66.     uint16_t mss = 0;
  67.     uint8_t* opt;
  68.     uint8_t* mssopt;

  70.     ppppoehdr = pppoe_hdr(skb);

  72.     pppphdr = (uint8_t*)ppppoehdr sizeof(struct pppoe_hdr);

  74.     /* check ppp protocol type */
  75.     if (pppphdr[0] & 0x01)
  76.     {
  77.         /* may be 8 bit protocol type ? */
  78.         if (pppphdr[0] != 0x21)
  79.         {
  80.             return;
  81.         }

  83.         piphdr = (struct iphdr*)(pppphdr 1);
  84.         minlen = 41; // tcp header len ip header len ppp header len
  85.     }
  86.     else
  87.     {
  88.         /* 16 bit protocol type, upper layer is ip, and the protocol value is 0x0021*/
  89.         if (pppphdr[0] != 0x00 || pppphdr[1] != 0x21)
  90.         {
  91.             return;
  92.         }
  93.         piphdr = (struct iphdr*)(pppphdr 2);
  94.         minlen = 42;
  95.     }

  97.     /* is it too short? */
  98.     len = (int)ntohs(ppppoehdr->length);
  99.     if (len < minlen)
  100.     {
  101.         return;
  102.     }

  104.     /* verify once more that it's ipv4 */
  105.     if (piphdr->version != 4)
  106.     {
  107.         return;
  108.     }

  110.     /* is it a fragment that's not at the beginning of the packet? */
  111.     if ( ntohs(piphdr->frag_off) & 0x1fff)
  112.     {
  113.         return;
  114.     }

  116.     /* is it tcp? */
  117.     if (piphdr->protocol != 0x06)
  118.     {
  119.         return;
  120.     }

  122.     /* get start of tcp header */
  123.     ptcphdr = (struct tcphdr*)((uint8_t*)piphdr (piphdr->ihl) * 4);

  125.     /* is syn set? */
  126.     if (!ptcphdr->syn)
  127.     {
  128.         return;
  129.     }

  131.     /* compute and verify tcp checksum -- do not touch a packet with a bad checksum */
  132.     csum = tcp_checksum((uint8_t*)piphdr, (uint8_t*)ptcphdr);
  133.     if (csum)
  134.     {
  135.         return;
  136.     }

  138.     /* look for existing mss option */
  139.     optlen = ntohs(ptcphdr->doff) * 4 - 20;

  141.     if (optlen <= 0)
  142.     {
  143.         return;
  144.     }

  146.     opt = (uint8_t*)ptcphdr 20;

  148.     while (optlen > 0)
  149.     {
  150.         switch (*opt)
  151.         {
  152.         case 0:    // end of options
  153.         case 1:    // empty option, always use for pad
  154.             len = 1;
  155.             break;
  156.         case 2:    // mss option
  157.             if (opt[1] != 4)
  158.             {
  159.                 return;
  160.             }

  162.             len = 4;
  163.             mss = opt[2] * 256 opt[3];
  164.             mssopt = opt;
  165.             break;
  166.         case 3:
  167.         case 4:
  168.         case 5:
  169.         case 8:
  170.             len = (int)opt[1];
  171.             break;
  172.         default:
  173.             return;

  175.         }

  177.         if (mss > 0)
  178.         {
  179.             break;
  180.         }

  182.         optlen -= len;
  183.         opt = len;

  185.     }

  187.     /* if mss not exists or it's low enough, do nothing */
  188.     if (!mss || mss <= clamp_mss)
  189.     {
  190.         return;
  191.     }

  193.     mssopt[2] = (((unsigned) clamp_mss) >> 8) & 0xff;
  194.     mssopt[3] = ((unsigned) clamp_mss) & 0xff;

  196.     /* recompute tcp checksum */
  197.     ptcphdr->check = 0;

  199.     csum = tcp_checksum((uint8_t*)piphdr, (uint8_t*)ptcphdr);
  200.     ptcphdr->check = csum;
  201. }

阅读(3729) | 评论(0) | 转发(0) |
0

上一篇：经典c面试题 -- 序列均衡

下一篇：openwrt: makefile 框架分析

给主人留下些什么吧！~~
| | | | |

凯发app官方网站 copyright 2001-2010 chinaunix.net all rights reserved 北京皓辰网域网络信息技术有限公司. 凯发k8官网下载客户端中心的版权所有

感谢所有关心和支持过chinaunix的朋友们
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图