{
           /* Compute Internet Checksum for "count" bytes
            *         beginning at location "addr".
            */
       register long sum = 0;

        while( count > 1 )  {
           /*  This is the inner loop */
               sum += * (unsigned short) addr++;
               count -= 2;
       }

           /*  Add left-over byte, if any */
       if( count > 0 )
               sum += * (unsigned char *) addr;

           /*  Fold 32-bit sum to 16 bits */
       while (sum>>16)
           sum = (sum & 0xffff) + (sum >> 16);

       checksum = ~sum;
   }

unsigned int hwport_rfc1071_checksum(const void *s_data, size_t s_size)
{ /* hwport_internet_checksum (RFC1071) */
    register uint32_t s_result = (uint32_t)0u;

    while(s_size > ((size_t)1u)) {
        s_result += (uint32_t)(*((const uint16_t *)s_data));
        s_data = ((const uint16_t *)s_data) + ((size_t)1u);
        s_size -= (size_t)2u;
    }

    if(s_size > ((size_t)0u)) {
        s_result += (uint32_t)(*((const uint8_t *)s_data));
    }

    /*  Fold 32-bit sum to 16 bits */
    s_result = (s_result >> 16) + (s_result & ((uint32_t)0xffffu));
    s_result += s_result >> 16;

    return((unsigned int)((~s_result) & ((uint32_t)0xffffu)));
}

static inline uint16_t csum16_add(uint16_t csum, /* BE16 */ uint16_t addend)
{
        uint16_t res = (uint16_t)csum;

        res += (uint16_t)addend;
        return (uint16_t)(res + (res < (uint16_t)addend));
}

static inline uint16_t csum16_sub(uint16_t csum, /* BE16 */ uint16_t addend)
{
        return csum16_add(csum, ~addend);
}

static inline void csum_replace2(uint16_t *sum, /* BE16 */ uint16_t old, /* BE16 */ uint16_t new)
{
        *sum = ~csum16_add(csum16_sub(~(*sum), old), new);
}

• 예를 들어 어떤 데이터의 checksum이 계산된 상태에서 특정 위치의 byte 값이 A 에서 B로 변경되었다면 다음과 같이 기존 checksum 에서 변화한 부분만 갱신하는데 사용할 수 있습니다. (데이터 일부가 변경되었음에도 전체를 다시 checksum 계산하는 것을 최소화 하는 효율적 구현의 필요성에 따른...)

  csum_replace2(&checksum, A, B);
  

  
  
  

• ip_forward 에서 ip_decrease_ttl 함수를 통해서 checksum의 update 구현으로 처리

• NAT 에 의해서 IP header의 출발지, 목적지 등이 변경될 때 필요
• XFRM 등의 Transform module(IPSec VPN 등) 에 의해서 변화직전에 반영할 때

• 옵션의 변경이 발생하면 재계산 필요

• 단편화 되면 서로 다른 Header를 갖고 이에 따른 각각의 체크섬이 재계산 되어야 합니다.

• 송신부에서는 호출전에 iph의 checksum 을 0으로 초기화 후에 호출하여 사용합니다.
• 포워딩이나 수신단계에서는 iph의 checksum값이 있는 상태로 이 함수를 호출하여 반환값 0이 반환되면 그 checksum이 맞다는 것을 확인하도록 사용한다는 점에 흥미로운 사용법이 존재합니다.

• 무언가 checksum 갱신이 될만한 사항은 이 값이 그에 맞는 값으로 상태값을 가져야 합니다.
  • CHECKSUM_NONE 또는 CHECKSUM_COMPLETE
    • 수신 패킷 (인입시 장치로부터 설정되는 skb->ip_summed)
      • skb->csum 값이 유효하지 않음을 의미
        • 장치가 하드웨어 checksum을 지원하지 못하는 경우
        • 충돌이 있는 프레임인 경우 (이 경우 하드웨어는 패킷을 버리지 않고 수신검증과정에서 이를 확인하여 검증하고 유무를 판단하는게 의도)
    • 송출 패킷 (TX 시에 skb->ip_summed)
      • checksum을 완료했으므로 장치에서 checksum을 더 할게 없음을 표현
  • CHECKSUM_UNNECESSARY
    • 송출/수신 패킷 (인입시 장치로부터 설정되거나 TX시에 skb->ip_summed)
      • NIC는 L4헤더의 체크섬과 의사 헤더의 체크섬(선택적)을 계산하고 검증함. 더 이상의 L4 checksum 검증 할 필요 없는 만큼 신뢰되는 패킷임을 의미
      • 오류가능성이 매우 낮은 경우 설정됨
      • 보통은 loopback 인 경우 구간신뢰가 가능하기 때문에 설정됨
  • CHECKSUM_PARTIAL
    • 송출 패킷 (TX 시에 skb->ip_summed)
      • 특정 부분까지 checksum을 수행(pseudo checksum)하였으나 나머지 L4 모든 부분에 대한 checksum이 수행되지 않은 상태 (보통 pseudo checksum은 계산하였으나 L4 checksum이 미완료인 상태)
        • 송출 직전까지는 checksum이 더 계산되어 완료되어야 하는 상태 !
        • IP header 가 변경될 때 L4 checksum은 다시 계산되어야 하는 경우가 빈번할 수 있으며 이것을 IP header 가 변경될 때는 pseudo checksum만 재계산하고 나머지 부분의 L4 checksum부분을 최종 전송 시점으로 미루어 불필요하게 다시 L4 계산하는 것을 줄일 수 있도록 한 것이 PARTIAL 상태 유지 관점의 구현입니다.
        • skb가 GSO/LRO 수신 구조의 L4 세그먼트를 IP 분할해야 하고 어차피 이 때 IP 헤더가 추가로 만들어지기 때문에 L4 checksum을 전송하기 이전에 완료하는 것이 의미가 없으므로 이 때 partial 상태를 유지하도록 하는 것이 유리할겁니다.
      • skb->csum_start 는 skb->head 로부터 아직 계산되지 않은 offset 을 나타냅니다.
      • skb->csum_offset 은 skb->csum_start 로부터 실제 checksum이 기록되어야 할 위치에 대한 offset을 나타냅니다.
      • skb->csum_not_inet 은 partial csum 값이 IP checksum 값이 아닌 CRC32c 등의 계산을 의미합니다. (SCTP protocol 같은 경우 이 경우가 있을 수 있겠습니다.)
      • hard_start_xmit 함수에 의해서 skb->csum_start 부터 skb->end 까지를 남은 계산을 수행하고 skb->csum_start + skb->csum_offset 에 checksum 결과를 기록합니다.
  • CHECKSUM_HW (장치 드라이버에서 내부적으로 사용)
    • 수신 패킷 (인입시 장치로부터 설정되는 skb->ip_summed)
      • NIC는 L4 헤더와 payload 에 대한 checksum을 수행하였고 skb->csum 필드에 복사하였음을 의미
      • 수신부에서는 이를 의사헤더와 함께 체크하여 검증하기만 하면 됨
    • 송출 패킷 (TX 시에 skb->ip_summed)
      • protocol 의 의사 헤더의 checksum을 해당 Header에 저장 후 나머지에 대한 checksum을 장치에서 수행하도록 함

• NETIF_F_NO_CSUM
  • 장치가 매우 신뢰되므로 L4 checksum이 필요하지 않은 경우 (보통 lookback 장치들)
• NETIF_F_IP_CSUM
  • 장치가 하드웨어에서 L4 checksum을 계산 가능하지만 TCP, UDP만 해당
• NETIF_F_HW_CSUM
  • 장치가 어떠한 protocol 에 대해서도 L4 checksum을 계산 가능

• csum_fold / csum_unfold
  • wsum type 이 32bits 인 경우 : 32bits 값의 최상위 16bits를 하위 16bits에 반영하는 과정(이를 fold한다고 함)을 처리하고 1의 보수 값
  • wsum type 이 64bits 인 경우 : 64bits 값의 최상위 32bits를 하위 32bits에 반영하고 다시 그 하위 32bits의 상위 16bits를 하위 16bits에 반영하는 과정을 처리하고 1의 보수 값
  • wsum type 과 sum16 type 을 이해할 필요가 있습니다.
    • wsum type 은 sum16 type 보다 큰 bits로 정의하며 보통 architecture 에 최적화된 bits 로 정의합니다.
    • wsum type 에서 sum16 type 으로 값을 맞추고 1의 보수 값을 취하는 것이 fold 과정이며 반대로 sum16에서 wsum type으로 확장하는 것은 unfold 과정입니다.
  • 대략 다음과 유사한 구현입니다.

    typedef uint16_t sum16_t;
    typedef uint32_t sum32_t;
    typedef uint64_t sum64_t;
    #if 0L
    # define wsum_width 32
    typedef sum32_t wsum_t;
    #else
    # define wsum_width 64
    typedef sum64_t wsum_t;
    #endif
    
    static __inline sum16_t csum_fold(wsum_t sum)
    {
    #if wsum_width == 64
        /* 64bits 값을 32bits 로 줄일 때 상위 32bits를 하위에 합산 */
        sum = (sum & 0xfffffffful) /* 하위 32bits */ + (sum >> 32) /* 상위 32bits */;
        sum = (sum & 0xfffffffful) /* 하위 32bits */ + (sum >> 32) /* 상위 32bits */;
    #endif
    
        /* 32bits 값을 16bits 로 줄일 때 상위 16bits를 하위에 합산 */
        sum = (sum & 0xffffu) /* 하위 16bits */ + (sum >> 16) /* 상위 16bits */;
        sum = (sum & 0xffffu) /* 하위 16bits */ + (sum >> 16) /* 상위 16bits */;
    
        returm (sum16_t)(~sum); /* 1의 보수로 반환 */
    }
    
    static __inline wsum_t csum_unfold(sum16_t sum)
    {
        return (wsum_t)sum;
    }
    

• csum_add / csum16_add / csumXX_add / ...
  • 부호 없는 두 값을 더하고 이 때 발생되는 carry값을 다시 더하는 함수
  • 대략 다음과 유사한 구현입니다.

    static __inline wsum_t csum_add(wsum_t sum, wsum_t addend)
    {
        sum += addend; /* 주어진 sum 과 addend 를 합산 */
        return sum + (sum < addend) /* carry */;
    }
    
    static __inline sum16_t csum16_add(sum16_t sum, sum16_t addend)
    {
        sum += addend; /* 주어진 sum 과 addend 를 합산 */
        return sum + (sum < addend) /* carry */;
    }
    

• csum_sub / csum16_sub / csumXX_sub / ...
  • 주어진 sum 에서 addend 를 빼는데 carry 도 함께 빼는 함수
  • 대략 다음과 유사한 구현입니다.

    static __inline wsum_t csum_sub(wsum_t sum, wsum_t addend)
    {
        return csum_add(sum, ~addend);
    }
    
    static __inline sum16_t csum16_sub(sum16_t sum, sum16_t addend)
    {
        return csum16_add(sum, ~addend);
    }
    

• csum_replace / csum_replace2 / csum_replace4 / csum_replaceX / ...
  • 주어진 sum 에서 이전 값 from 을 빼고 최신 값 to를 더하여 from 에서 to 로 변경된 값 만큼은 sum을 갱신하는 함수
  • 주로 NAT의 변환이나 TTL 감소 등에 의한 checksum 을 일부가 변경되는 경우 전체 checksum을 다시 계산하지 않고 변화된 부분만 checksum에 반영하는 함수
  • 여기서 주어진 from과 to는 network order 기준으로 사용해야 합니다.
  • 대략 다음과 유사한 구현입니다.

    static __inline void csum_replace(wsum_t *sum_ptr, wsum_t from, wsum_t to)
    {
        *sum_ptr = ~csum_add(csum_sub(*sum_ptr, from), to);
    }
    
    static __inline void csum_replace2(sum16_t *sum_ptr, uint16_t from, uint16_t to)
    {
        *sum_ptr = ~csum16_add(csum16_sub(~(*sum_ptr), (sum16_t)from), (sum16_t)to);
    }
    
    static __inline void csum_replace4(sum16_t *sum_ptr, uint32_t from, uint32_t to)
    {
        *sum_ptr = csum_fold(csum_add(csum_sub(~csum_unfold(*sum_ptr), (wsum_t)from), (wsum_t)to));
    }
    

• csum_partial / csum_partial_XX / ...
  • 주어진 data 영역을 주어진 sum 에 합산합니다.
  • 대략 다음과 유사한 구현입니다.

    static __inline wsum_t csum_partial(const void *data, size_t size, wsum_t sum)
    {
        while (size >= sizeof(sum16_t)) {
            sum = csum_add(sum, (wsum_t)(*((const uint16_t *)data)));
            size -= sizeof(uint16_t);
            data = (const void *)(((const uint8_t *)data) + sizeof(uint16_t));
        }
    
        if (size > ((size_t)0u)) { /* 남은 홀수 합산 */
            sum = csum_add(sum, (wsum_t)htons(((uint16_t)(*((const uint8_t *)data))) << 8));
        }
    
        return sum;
    }
    

• ip_compute_csum
  • checksum을 수행하는 일반 목적의 함수
    • csum_partial 후 csum_fold 하는 것
  • 대략 다음과 유사한 구현입니다.

    static __inline sum16_t ip_compute_csum(const void *data, size_t size)
    {
        return csum_fold(csum_partial(data, size, (wsum_t)0u));
    }
    

• ip_fast_csum
  • IP Header와 길이(ip header의 ip length 필드 값 그대로)를 입력으로 받아 ip checksum을 계산하여 반환
  • ip_compute_csum의 IP header만을 위한 최적화된 변형인 함수로 4 octet boundaries 조건 및 ihl 값의 범위제한조건등을 통하여 보다 최적화된 구현을 가질 수 있는 함수입니다.
  • 대략 다음과 유사한 구현입니다.

    static __inline sum16_t ip_fast_csum(const void *iph, unsigned int ihl)
    { /* ip_compute_csum optimized, 4 octet boundaries */
    #if 0L /* fast, no carry */
        wsum_t sum = (wsum_t)0u;
    
        while (ihl > 0u) {
            sum = csum_add(sum, (wsum_t)(*((const uint32_t *)iph)));
            --ihl;
            iph = (const void *)(((const uint8_t *)iph) + sizeof(uint32_t));
        }
    
        return (sum16_t)(~wcsum_to_sum16((uint32_t)sum));
    #else /* full */
        return ip_compute_csum(iph, (size_t)(ihl << 2));
    #endif
    }
    

• ip_send_check
  • 송출되는 IP packet의 checksum을 계산
  • iph->check를 0으로 초기화 하고 ip_fast_csum을 호출하는 wrapper 함수
  • 대략 다음과 유사한 구현입니다.

    static __inline void ip_send_check(struct iphdr *iph)
    {
        iph->check = 0;
        iph->check = ip_fast_csum((const void *)iph, (unsigned int)iph->ihl);
    }
    

• ip_decrease_ttl
  • TTL을 감소시키고 갱신된 변화값만큼만 checksum을 갱신하는 함수 (checksum을 전체 계산하는 것이 아닌 TTL 1감소하는 것에 대한 update만 수행)
  • ip_forward 에서 TTL 감소 및 checksum 갱신하는 목적으로 사용
  • 대략 다음과 유사한 구현입니다.

    static __inline int ip_decrease_ttl(struct iphdr *iph)
    {
        wsum_t sum = (wsum_t)iph->check;
    
        sum += (wsum_t)htons(0x0100);
        iph->check = (sum16_t)(sum + (sum >= ((wsum_t)0xffffu)));
    
        return --iph->ttl;
    }
    

• csum_tcpudp_nofold / csum_tcpudp_magic / tcp_v4_check / udp_v4_check / ...
  • IPv4 TCP/UDP 의사헤더를 가상으로 만들어 checksum을 수행
  • 보통은 csum_partial로 계산된 의사헤더를 제외한 부분의 checksum 결과를 먼저 얻고 이 값과 csum_tcpudp_magic에 의해서 계산된 의사헤더 checksum을 더하는 과정을 하게 됨
  • 대략 다음과 유사한 구현입니다.

    static __inline wsum_t csum_tcpudp_nofold(uint32_t saddr, uint32_t daddr, uint32_t len, uint8_t proto, wsum_t sum)
    {
        sum = csum_add(sum, (wsum_t)saddr);
        sum = csum_add(sum, (wsum_t)daddr);
        sum = csum_add(sum, (wsum_t)htonl(len));
        sum = csum_add(sum, (wsum_t)htonl(proto));
    
        return sum;
    }
    
    static __inline sum16_t csum_tcpudp_magic(uint32_t saddr, uint32_t daddr, uint32_t len, uint8_t proto, wsum_t sum)
    {
        return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));
    }
    
    static __inline sum16_t tcp_v4_check(uint32_t len, uint32_t saddr, uint32_t daddr, wsum_t sum)
    {
        return csum_tcpudp_magic(saddr, daddr, len, IPPROTO_TCP, sum);
    }
    
    static __inline sum16_t udp_v4_check(uint32_t len, uint32_t saddr, uint32_t daddr, wsum_t sum)
    {
        return csum_tcpudp_magic(saddr, daddr, len, IPPROTO_UDP, sum);
    }
    

  • 참고) Pseudo header format (IPv4 인 경우, RFC793 Section-3.1)

    Pseudo header format (IPv4)

    0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31	Description
    32-bit Source Address																																↑↓8 bytes	↑↓12 bytes
    32-bit Destination Address
    8-bit Zero								8-bit PTCL(Protocol)								16-bit TCP Length (TCP Header + Data)																↑↓4 bytes

• csum_ipv6_magic / tcp_v6_check / udp_v6_check / ...
  • IPv6 의사헤더를 가상으로 만들어 checksum을 수행
  • 보통은 csum_partial로 계산된 의사헤더를 제외한 부분의 checksum 결과를 먼저 얻고 이 값과 csum_ipv6_magic에 의해서 계산된 의사헤더 checksum을 더하는 과정을 하게 됨
  • 대략 다음과 유사한 구현입니다.

    static __inline sum16_t csum_ipv6_magic(const struct in6_addr *saddr, const struct in6_addr *daddr, uint32_t len, uint8_t proto, wsum_t sum)
    {
        sum = csum_partial((const void *)saddr, sizeof(*saddr), sum);
        sum = csum_partial((const void *)daddr, sizeof(*saddr), sum);
        sum = csum_add(sum, (wsum_t)htonl(len));
        sum = csum_add(sum, (wsum_t)htonl(proto));
    
        return csum_fold(sum);
    }
    
    static __inline sum16_t tcp_v6_check(uint32_t len, const struct in6_addr *saddr, const struct in6_addr *daddr, wsum_t sum)
    {
        return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, sum);
    }
    
    static __inline sum16_t udp_v6_check(uint32_t len, const struct in6_addr *saddr, const struct in6_addr *daddr, wsum_t sum)
    {
        return csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP, sum);
    }
    

  • 참고) Pseudo header format (IPv6 인 경우, RFC2460 Section-8.1)

    Pseudo header format (IPv6)

    0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31	Description
    128-bit Source Address																																↑↓32 bytes	↑↓40 bytes
    128-bit Destination Address (Final destination address)
    32-bit Upper-Layer Packet Length																																↑↓4 bytes
    24-bit Zero																															8-bit Next Header	↑↓4 bytes

• csum_block_add
  • checksum을 증가하는 방향으로 계산 (추가되는 block에 대한 checksum을 계산하여 이전 결과에 합산)
• csum_block_sub
  • checksum을 빼는 방향으로 계산 (checksum된 결과에서 제거되는 block에 대한 checksum을 계산하여 뺌)
• skb_checksum
  • skb에 특화된 일반 함수
• skb_checksum_help
  • 인입 패킷에서는 L4 하드웨어 checksum을 검증하기 위해서 사용
  • 인출 패킷에서는 L4 checksum을 계산
    • skb->ip_summed 가 CHECKSUM_PARTIAL 상태인 경우 skb->ip_summed 가 CHECKSUM_NONE이 되도록 checksum 남은 부분을 완료처리하게 됩니다.

• 방법1)

  struct iphdr *iph = ip_hdr(skb);
  
  iph->check = 0; // 0으로 초기화 필요
  iph->check = csum_fold(csum_partial(iph, iph->ihl << 2, 0));
  

• 방법2)

  struct iphdr *iph = ip_hdr(skb);
  
  iph->check = 0; // 0으로 초기화 필요
  iph->check = ip_compute_csum(iph, iph->ihl << 2);
  

• 방법3) => 대부분은 이 방법을 권장

  struct iphdr *iph = ip_hdr(skb);
  
  iph->check = 0; // 0으로 초기화 필요
  iph->check = ip_fast_csum(iph, iph->ihl /* 4 octet boundaries */); // ip_fast_csum 함수는 IPv4 header checksum 만을 위해서 성능적으로 특화된 함수입니다.
  

• 방법4)

  struct iphdr *iph = ip_hdr(skb);
  
  ip_send_check(iph); // ip_send_check 함수는 내부적으로 iph->check을 0으로 초기화 하고 계산을 하여 iph->check 에 저장까지 합니다.
  

• 방법1)

  struct iphdr *iph = ip_hdr(skb);
  
  if (unlikely(csum_fold(csum_partial(iph, iph->ihl << 2, 0)) != 0)) {
      /* checksum error */
  }
  

• 방법2)

  struct iphdr *iph = ip_hdr(skb);
  
  if (unlikely(ip_compute_csum(iph, iph->ihl << 2) != 0)) {
      /* checksum error */
  }
  

• 방법3) => 대부분은 이 방법을 권장

  struct iphdr *iph = ip_hdr(skb);
  
  if (unlikely(ip_fast_csum(iph, iph->ihl) != 0)) {
      /* checksum error */
  }
  

• 방법1)

  struct iphdr *iph = ip_hdr(skb);
  __sum16 verify_csum = ip_fast_csum(iph, iph->ihl);
  
  if (unlikely(verify_csum != 0)) {
      /* checksum error */
  
      /* checksum 을 다시 계산하는 방법 (그냥 다시 계산하는 방법이지만 ip_fast_csum을 두 번이나 반복하는 계산이 있다는 점) */
      iph->check = 0;
      iph->check = ip_fast_csum(iph, iph->ihl);
  
      /* 이제 IPv4 checksum이 올바르게 재계산되었습니다. */
  }
  

• 방법2) => 대부분은 이 방법을 권장

  struct iphdr *iph = ip_hdr(skb);
  __sum16 verify_csum = ip_fast_csum(iph, iph->ihl);
  
  if (unlikely(verify_csum != 0)) {
      /* checksum error */
  
      /* 이미 ip_fast_csum 함수로 검증계산을 하였기 때문에 잘못된 값만 보정(뺄셈)하면 ip checksum 이 올바르게 된다는 점. */
      iph->check = ~csum16_sub(~verify_csum /* 검증값이 1의 보수로 0이 아닌 상태 */, iph->check /* 잘못계산된 저장값을 빼주기 위해 */);
  
      /* 이제 IPv4 checksum이 올바르게 재계산되었습니다. */
  }