Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1908535
  • 博文数量: 376
  • 博客积分: 2147
  • 博客等级: 大尉
  • 技术积分: 3642
  • 用 户 组: 普通用户
  • 注册时间: 2012-02-06 10:47
文章分类

全部博文(376)

文章存档

2019年(3)

2017年(28)

2016年(15)

2015年(17)

2014年(182)

2013年(16)

2012年(115)

我的朋友

分类: LINUX

2015-09-11 14:52:47

概述

 

TCP校验和是一个端到端的校验和,由发送端计算,然后由接收端验证。其目的是为了发现TCP首部和数据在发送端到

接收端之间发生的任何改动。如果接收方检测到校验和有差错,则TCP段会被直接丢弃。

TCP校验和覆盖TCP首部和TCP数据,而IP首部中的校验和只覆盖IP的首部,不覆盖IP数据报中的任何数据。

TCP的校验和是必需的,而UDP的校验和是可选的。

TCP和UDP计算校验和时,都要加上一个12字节的伪首部。

 

Author : zhangskd @ csdn blog

 

伪首部

伪首部共有12字节,包含如下信息:源IP地址、目的IP地址、保留字节(置0)、传输层协议号(TCP是6)、TCP报文长度(报头+数据)。

伪首部是为了增加TCP校验和的检错能力:如检查TCP报文是否收错了(目的IP地址)、传输层协议是否选对了(传输层协议号)等。

 

定义

 

(1) RFC 793的TCP校验和定义

The checksum field is the 16 bit one's complement of the one's complement sum of all 16-bit words in the header and text.

If a segment contains an odd number of header and text octets to be checksummed, the last octet is padded on the right

with zeros to form a 16-bit word for checksum purposes. The pad is not transmitted as part of the segment. While computing

the checksum, the checksum field itself is replaced with zeros.

 

上述的定义说得很明确:

首先,把伪首部、TCP报头、TCP数据分为16位的字,如果总长度为奇数个字节,则在最后增添一个位都为0的字节。

            把TCP报头中的校验和字段置为0(否则就陷入鸡生蛋还是蛋生鸡的问题)。

其次,用反码相加法累加所有的16位字(进位也要累加)。

最后,对计算结果取反,作为TCP的校验和。

 

(2) RFC 1071的IP校验和定义

1. Adjacent octets to be checksummed are paired to form 16-bit integers, and the 1's complement sum of these

    16-bit integers is formed.

2. To generate a checksum, the checksum field itself is cleared, the 16-bit 1's complement sum is computed over

    the octets concerned, and the 1's complement of this sum is placed in the checksum field.

3. To check a checksum, the 1's complement sum is computed over the same set of octets, including the checksum

    field. If the result is all 1 bits (-0 in 1's complement arithmetic), the check succeeds.

 

可以看到,TCP校验和、IP校验和的计算方法是基本一致的,除了计算的范围不同。

 

实现

 

基于2.6.18、x86_64。

csum_tcpudp_nofold()按4字节累加伪首部到sum中。

[java] view plaincopy
  1. static inline unsigned long csum_tcpudp_nofold (unsigned long saddr, unsigned long daddr,  
  2.                                                 unsigned short len, unsigned short proto,  
  3.                                                 unsigned int sum)  
  4. {  
  5.     asm("addl %1, %0\n"    /* 累加daddr */  
  6.         "adcl %2, %0\n"    /* 累加saddr */  
  7.         "adcl %3, %0\n"    /* 累加len(2字节), proto, 0*/  
  8.         "adcl $0, %0\n"    /*加上进位 */  
  9.         : "=r" (sum)  
  10.         : "g" (daddr), "g" (saddr), "g" ((ntohs(len) << 16) + proto*256), "0" (sum));  
  11.     return sum;  
  12. }   

 

csum_tcpudp_magic()产生最终的校验和。

首先,按4字节累加伪首部到sum中。

其次,累加sum的低16位、sum的高16位,并且对累加的结果取反。

最后,截取sum的高16位,作为校验和。

[java] view plaincopy
  1. static inline unsigned short int csum_tcpudp_magic(unsigned long saddr, unsigned long daddr,  
  2.                                                    unsigned short len, unsigned short proto,  
  3.                                                    unsigned int sum)  
  4. {  
  5.     return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));  
  6. }  
  7.   
  8. static inline unsigned int csum_fold(unsigned int sum)  
  9. {  
  10.     __asm__(  
  11.         "addl %1, %0\n"  
  12.         "adcl 0xffff, %0"  
  13.         : "=r" (sum)  
  14.         : "r" (sum << 16), "0" (sum & 0xffff0000)   
  15.   
  16.         /* 将sum的低16位,作为寄存器1的高16位,寄存器1的低16位补0。 
  17.           * 将sum的高16位,作为寄存器0的高16位,寄存器0的低16位补0。 
  18.           * 这样,addl %1, %0就累加了sum的高16位和低16位。 
  19.           * 
  20.          * 还要考虑进位。如果有进位,adcl 0xfff, %0为:0x1 + 0xffff + %0,寄存器0的高16位加1。 
  21.           * 如果没有进位,adcl 0xffff, %0为:0xffff + %0,对寄存器0的高16位无影响。 
  22.           */  
  23.   
  24.     );  
  25.   
  26.     return (~sum) >> 16/* 对sum取反,返回它的高16位,作为最终的校验和 */  
  27. }  

 

发送校验

 

[java] view plaincopy
  1. #define CHECKSUM_NONE 0 /* 需要由传输层自己计算校验和 */  
  2. #define CHECKSUM_HW 1 /* 由硬件计算报头和首部的校验和 */  
  3. #define CHECKSUM_UNNECESSARY 2 /* 表示不需要校验,或者已经成功校验了 */  
  4. #define CHECKSUM_PARTIAL CHECKSUM_HW  
  5. #define CHECKSUM_COMPLETE CHECKSUM_HW  

 

@tcp_transmit_skb()

    icsk->icsk_af_ops->send_check(sk, skb->len, skb); /* 计算校验和 */

 

[java] view plaincopy
  1. void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)  
  2. {  
  3.     struct inet_sock *inet = inet_sk(sk);  
  4.     struct tcphdr *th = skb->h.th;  
  5.    
  6.     if (skb->ip_summed == CHECKSUM_HW) {  
  7.         /* 只计算伪首部,TCP报头和TCP数据的累加由硬件完成 */  
  8.         th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0);  
  9.         skb->csum = offsetof(struct tcphdr, check); /* 校验和值在TCP首部的偏移 */  
  10.   
  11.     } else {  
  12.         /* tcp_v4_check累加伪首部,获取最终的校验和。 
  13.          * csum_partial累加TCP报头。 
  14.          * 那么skb->csum应该是TCP数据部分的累加,这是在从用户空间复制时顺便累加的。 
  15.          */  
  16.         th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,  
  17.                                  csum_partial((char *)th, th->doff << 2, skb->csum));  
  18.     }  
  19. }  
[java] view plaincopy
  1. unsigned csum_partial(const unsigned char *buff, unsigned len, unsigned sum)  
  2. {  
  3.     return add32_with_carry(do_csum(buff, len), sum);  
  4. }  
  5.   
  6. static inline unsigned add32_with_carry(unsigned a, unsigned b)  
  7. {  
  8.     asm("addl %2, %0\n\t"  
  9.              "adcl $0, %0"  
  10.              : "=r" (a)  
  11.              : "0" (a), "r" (b));  
  12.     return a;  
  13. }   

 

do_csum()用于计算一段内存的校验和,这里用于累加TCP报头。

具体计算时用到一些技巧:

1. 反码累加时,按16位、32位、64位来累加的效果是一样的。

2. 使用内存对齐,减少内存操作的次数。

[java] view plaincopy
  1. static __force_inline unsigned do_csum(const unsigned char *buff, unsigned len)  
  2. {  
  3.     unsigned odd, count;  
  4.     unsigned long result = 0;  
  5.   
  6.     if (unlikely(len == 0))  
  7.         return result;  
  8.   
  9.     /* 使起始地址为XXX0,接下来可按2字节对齐 */  
  10.     odd = 1 & (unsigned long) buff;  
  11.     if (unlikely(odd)) {  
  12.         result = *buff << 8/* 因为机器是小端的 */  
  13.         len--;  
  14.         buff++;  
  15.     }  
  16.     count = len >> 1/* nr of 16-bit words,这里可能余下1字节未算,最后会处理*/  
  17.   
  18.     if (count) {  
  19.         /* 使起始地址为XX00,接下来可按4字节对齐 */  
  20.         if (2 & (unsigned long) buff) {  
  21.             result += *(unsigned short *)buff;  
  22.             count--;  
  23.             len -= 2;  
  24.             buff += 2;  
  25.         }  
  26.         count >>= 1/* nr of 32-bit words,这里可能余下2字节未算,最后会处理 */  
  27.   
  28.         if (count) {  
  29.             unsigned long zero;  
  30.             unsigned count64;  
  31.             /* 使起始地址为X000,接下来可按8字节对齐 */  
  32.             if (4 & (unsigned long)buff) {  
  33.                 result += *(unsigned int *)buff;  
  34.                 count--;  
  35.                 len -= 4;  
  36.                 buff += 4;  
  37.             }  
  38.             count >>= 1/* nr of 64-bit words,这里可能余下4字节未算,最后会处理*/  
  39.   
  40.             /* main loop using 64byte blocks */  
  41.             zero = 0;  
  42.             count64 = count >> 3/* 64字节的块数,这里可能余下56字节未算,最后会处理 */  
  43.             while (count64) { /* 反码累加所有的64字节块 */  
  44.                 asm ("addq 0*8(%[src]), %[res]\n\t"    /* b、w、l、q分别对应8、16、32、64位操作 */  
  45.                           "addq 1*8(%[src]), %[res]\n\t"    /* [src]为指定寄存器的别名,效果应该等同于0、1等 */  
  46.                           "adcq 2*8(%[src]), %[res]\n\t"  
  47.                           "adcq 3*8(%[src]), %[res]\n\t"  
  48.                           "adcq 4*8(%[src]), %[res]\n\t"  
  49.                           "adcq 5*8(%[src]), %[res]\n\t"  
  50.                           "adcq 6*8(%[src]), %[res]\n\t"  
  51.                           "adcq 7*8(%[src]), %[res]\n\t"  
  52.                           "adcq %[zero], %[res]"  
  53.                           : [res] "=r" (result)  
  54.                           : [src] "r" (buff), [zero] "r" (zero), "[res]" (result));  
  55.                 buff += 64;  
  56.                 count64--;  
  57.             }  
  58.   
  59.             /* 从这里开始,反序处理之前可能漏算的字节 */  
  60.   
  61.             /* last upto 7 8byte blocks,前面按8个8字节做计算单位,所以最多可能剩下7个8字节 */  
  62.             count %= 8;  
  63.             while (count) {  
  64.                 asm ("addq %1, %0\n\t"  
  65.                      "adcq %2, %0\n"  
  66.                      : "=r" (result)  
  67.                      : "m" (*(unsigned long *)buff), "r" (zero), "0" (result));  
  68.                 --count;  
  69.                 buff += 8;  
  70.             }  
  71.   
  72.             /* 带进位累加result的高32位和低32位 */  
  73.             result = add32_with_carry(result>>32, result&0xffffffff);  
  74.   
  75.             /* 之前始按8字节对齐,可能有4字节剩下 */  
  76.             if (len & 4) {  
  77.                 result += *(unsigned int *) buff;  
  78.                 buff += 4;  
  79.             }  
  80.         }  
  81.   
  82.        /* 更早前按4字节对齐,可能有2字节剩下 */  
  83.         if (len & 2) {  
  84.             result += *(unsigned short *) buff;  
  85.             buff += 2;  
  86.         }  
  87.     }  
  88.   
  89.     /* 最早之前按2字节对齐,可能有1字节剩下 */  
  90.     if (len & 1)  
  91.         result += *buff;  
  92.   
  93.     /* 再次带进位累加result的高32位和低32位 */  
  94.     result = add32_with_carry(result>>32, result & 0xffffffff);   
  95.   
  96.     /* 这里涉及到一个技巧,用于处理初始地址为奇数的情况 */  
  97.     if (unlikely(odd)) {  
  98.         result = from32to16(result); /* 累加到result的低16位 */  
  99.         /* result为:0 0 a b 
  100.          * 然后交换a和b,result变为:0 0 b a 
  101.          */  
  102.         result = ((result >> 8) & 0xff) | ((result & oxff) << 8);  
  103.     }  
  104.   
  105.     return result; /* 返回result的低32位 */  
  106. }  
[java] view plaincopy
  1. static inline unsigned short from32to16(unsigned a)  
  2. {  
  3.     unsigned short b = a >> 16;  
  4.     asm ("addw %w2, %w0\n\t"  
  5.               "adcw $0, %w0\n"  
  6.               : "=r" (b)  
  7.               : "0" (b), "r" (a));  
  8.     return b;  
  9. }  

 

csum_partial_copy_from_user()用于拷贝用户空间数据到内核空间,同时计算用户数据的校验和,

结果保存到skb->csum中(X86_64)。

[java] view plaincopy
  1. /** 
  2.  * csum_partial_copy_from_user - Copy and checksum from user space. 
  3.  * @src: source address (user space) 
  4.  * @dst: destination address 
  5.  * @len: number of bytes to be copied. 
  6.  * @isum: initial sum that is added into the result (32bit unfolded) 
  7.  * @errp: set to -EFAULT for an bad source address. 
  8.  * 
  9.  * Returns an 32bit unfolded checksum of the buffer. 
  10.  * src and dst are best aligned to 64bits. 
  11.  */  
  12.   
  13. unsigned int csum_partial_copy_from_user(const unsigned char __user *src,  
  14.                                   unsigned char *dst, int len, unsigned int isum, int *errp)  
  15. {  
  16.     might_sleep();  
  17.     *errp = 0;  
  18.   
  19.     if (likely(access_ok(VERIFY_READ, src, len))) {  
  20.   
  21.         /* Why 6, not 7? To handle odd addresses aligned we would need to do considerable 
  22.          * complications to fix the checksum which is defined as an 16bit accumulator. The fix 
  23.          * alignment code is primarily for performance compatibility with 32bit and that will handle 
  24.          * odd addresses slowly too. 
  25.          * 处理X010、X100、X110的起始地址。不处理X001,因为这会使复杂度大增加。 
  26.          */  
  27.         if (unlikely((unsigned long)src & 6)) {  
  28.             while (((unsigned long)src & 6) && len >= 2) {  
  29.                 __u16 val16;  
  30.                 *errp = __get_user(val16, (__u16 __user *)src);  
  31.                 if (*errp)  
  32.                     return isum;  
  33.                 *(__u16 *)dst = val16;  
  34.                 isum = add32_with_carry(isum, val16);  
  35.                 src += 2;  
  36.                 dst += 2;  
  37.                 len -= 2;  
  38.             }  
  39.         }  
  40.   
  41.         /* 计算函数是用纯汇编实现的,应该是因为效率吧 */  
  42.         isum = csum_parial_copy_generic((__force void *)src, dst, len, isum, errp, NULL);  
  43.   
  44.         if (likely(*errp == 0))  
  45.             return isum; /* 成功 */  
  46.     }  
  47.   
  48.     *errp = -EFAULT;  
  49.     memset(dst, 0, len);  
  50.     return isum;  
  51. }  

 

上述的实现比较复杂,来看下最简单的csum_partial_copy_from_user()实现(um)。

[java] view plaincopy
  1. unsigned int csum_partial_copy_from_user(const unsigned char *src,  
  2.                                          unsigned char *dst, int len, int sum,  
  3.                                          int *err_ptr)  
  4. {  
  5.     if (copy_from_user(dst, src, len)) { /* 拷贝用户空间数据到内核空间 */  
  6.         *err_ptr = -EFAULT; /* bad address */  
  7.         return (-1);  
  8.     }  
  9.   
  10.     return csum_partial(dst, len, sum); /* 计算用户数据的校验和,会存到skb->csum中 */  
  11. }  

 

接收校验

 

@tcp_v4_rcv

    /* 检查校验和 */

    if (skb->ip_summed != CHECKSUM_UNNECESSARY && tcp_v4_checksum_init(skb))

        goto bad_packet;   

 

接收校验的第一部分,主要是计算伪首部。

[java] view plaincopy
  1. static int tcp_v4_checksum_init(struct sk_buff *skb)  
  2. {  
  3.     /* 如果TCP报头、TCP数据的反码累加已经由硬件完成 */  
  4.     if (skb->ip_summed == CHECKSUM_HW) {  
  5.   
  6.         /* 现在只需要再累加上伪首部,取反获取最终的校验和。 
  7.          * 校验和为0时,表示TCP数据报正确。 
  8.          */  
  9.         if (! tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr, skb->nh.iph->daddr, skb->csum)) {  
  10.             skb->ip_summed = CHECKSUM_UNNECESSARY;  
  11.             return 0/* 校验成功 */  
  12.   
  13.         } /* 没有else失败退出吗?*/  
  14.     }  
  15.   
  16.     /* 对伪首部进行反码累加,主要用于软件方法 */  
  17.     skb->csum = csum_tcpudp_nofold(skb->nh.iph->saddr, skb->nh.iph->daddr, skb->len, IPPROTO_TCP, 0);  
  18.    
  19.   
  20.     /* 对于长度小于76字节的小包,接着累加TCP报头和报文,完成校验;否则,以后再完成检验。*/  
  21.     if (skb->len <= 76) {  
  22.         return __skb_checksum_complete(skb);  
  23.     }  
  24. }  

 

接收校验的第二部分,计算报头和报文。

tcp_v4_rcv、tcp_v4_do_rcv()

    | --> tcp_checksum_complete()

                | --> __tcp_checksum_complete()

                            | --> __skb_checksum_complete()

 

tcp_rcv_established()

    | --> tcp_checksum_complete_user()

                | --> __tcp_checksum_complete_user()

                            | --> __tcp_checksum_complete()

                                        | --> __skb_checksum_complete()

 

[java] view plaincopy
  1. unsigned int __skb_checksum_complete(struct sk_buff *skb)  
  2. {  
  3.     unsigned int sum;  
  4.   
  5.     sum = (u16) csum_fold(skb_checksum(skb, 0, skb->len, skb->csum));  
  6.   
  7.     if (likely(!sum)) { /* sum为0表示成功了 */  
  8.         /* 硬件检测失败,软件检测成功了,说明硬件检测有误 */  
  9.         if (unlikely(skb->ip_summed == CHECKSUM_HW))  
  10.             netdev_rx_csum_fault(skb->dev);  
  11.         skb->ip_summed = CHECKSUM_UNNECESSARY;  
  12.     }  
  13.     return sum;  
  14. }  

 

计算skb包的校验和时,可以指定相对于skb->data的偏移量offset。

由于skb包可能由分页和分段,所以需要考虑skb->data + offset是位于此skb段的线性区中、

还是此skb的分页中,或者位于其它分段中。这个函数逻辑比较复杂。

[java] view plaincopy
  1. /* Checksum skb data. */  
  2. unsigned int skb_checksum(const struct sk_buff *skb, int offset, int len, unsigned int csum)  
  3. {  
  4.     int start = skb_headlen(skb); /* 线性区域长度 */  
  5.     /* copy > 0,说明offset在线性区域中。 
  6.      * copy < 0,说明offset在此skb的分页数据中,或者在其它分段skb中。 
  7.      */  
  8.     int i, copy = start - offset;  
  9.     int pos = 0/* 表示校验了多少数据 */  
  10.   
  11.     /* Checksum header. */  
  12.     if (copy > 0) { /* 说明offset在本skb的线性区域中 */  
  13.         if (copy > len)  
  14.             copy = len; /* 不能超过指定的校验长度 */  
  15.   
  16.         /* 累加copy长度的线性区校验 */  
  17.         csum = csum_partial(skb->data + offset, copy, csum);  
  18.   
  19.         if ((len -= copy) == 0)  
  20.             return csum;  
  21.   
  22.         offset += copy; /* 接下来从这里继续处理 */  
  23.         pos = copy; /* 已处理数据长 */  
  24.     }  
  25.   
  26.     /* 累加本skb分页数据的校验和 */  
  27.     for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {  
  28.         int end;  
  29.         BUG_TRAP(start <= offset + len);  
  30.       
  31.         end = start + skb_shinfo(skb)->frags[i].size;  
  32.   
  33.         if ((copy = end - offset) > 0) { /* 如果offset位于本页中,或者线性区中 */  
  34.             unsigned int csum2;  
  35.             u8 *vaddr; /* 8位够吗?*/  
  36.             skb_frag_t *frag = &skb_shinfo(skb)->frags[i];  
  37.    
  38.             if (copy > len)  
  39.                 copy = len;  
  40.   
  41.             vaddr = kmap_skb_frag(frag); /* 把物理页映射到内核空间 */  
  42.             csum2 = csum_partial(vaddr + frag->page_offset + offset - start, copy, 0);  
  43.             kunmap_skb_frag(vaddr); /* 解除映射 */  
  44.   
  45.             /* 如果pos为奇数,需要对csum2进行处理。 
  46.              * csum2:a, b, c, d => b, a, d, c 
  47.              */  
  48.             csum = csum_block_add(csum, csum2, pos);  
  49.   
  50.             if (! (len -= copy))  
  51.                 return csum;  
  52.   
  53.             offset += copy;  
  54.             pos += copy;  
  55.         }  
  56.         start = end; /* 接下来从这里处理 */  
  57.     }  
  58.    
  59.     /* 如果此skb是个大包,还有其它分段 */  
  60.     if (skb_shinfo(skb)->frag_list) {  
  61.         struct sk_buff *list = skb_shinfo(skb)->frag_list;  
  62.   
  63.         for (; list; list = list->next) {  
  64.             int end;  
  65.             BUG_TRAP(start <= offset + len);  
  66.    
  67.             end = start + list->len;  
  68.   
  69.             if ((copy = end - offset) > 0) { /* 如果offset位于此skb分段中,或者分页,或者线性区 */  
  70.                 unsigned int csum2;  
  71.                 if (copy > len)  
  72.                     copy = len;  
  73.   
  74.                 csum2 = skb_checksum(list, offset - start, copy, 0); /* 递归调用 */  
  75.                 csum = csum_block_add(csum, csum2, pos);  
  76.                 if ((len -= copy) == 0)  
  77.                     return csum;  
  78.   
  79.                 offset += copy;  
  80.                 pos += copy;  
  81.             }  
  82.             start = end;  
  83.         }  
  84.     }  
  85.   
  86.     BUG_ON(len);  
  87.     return csum;  
  88. }  


 

版权声明:本文为博主原创文章,未经博主允许不得转载。

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

上一篇:IP校验和

下一篇:gcc内嵌汇编用法

给主人留下些什么吧!~~