Подсчет контрольной суммы заголовка IP пакета

/*********************************************************************************************
*в функции checksum рассчитывается только заголовок пакета
*заголовок разбивается на 16 битные величины
*и все эти кусочки складываются  
*Перед использованием функции checksum  нужно обнулить контрольную сумму в заголовке пакета
**********************************************************************************************/
uint16_t checksum(uint8_t *ptr, uint16_t len)
{
    uint32_t sum = 0; //сумма в 16 бит может не уместиться поэтому создаем переменную для 32 бит
    
    while(len > 0) // пока длина заголовка пакета больше нуля - складываем 
    {
        sum += (uint16_t) (((uint32_t)*ptr<<8) |*(ptr+1));//складываем кусочки заголовка по 16 бит
        ptr+=2; //переходим по указателю еще на 16 бит
        len-=2; //длину соответственно уменьшаем на 2 байта
    }
    if (len) sum+=((uint32_t)*ptr)<<8; // если длинна уменьшилась не до нуля, то к полученной сумме прибавляем еще 
                                                // старший байт. т.е. старший байт становится по адресу ptr, а младший освобождается
    while(sum>>16) sum = (uint16_t)sum+(sum>>16); //если бы старшая величина была бы равна 0 то мы вышли бы из этого цикла, в противном случае в старшей части что-то осталось и поэтому снова производим операцию сложения
    return ~((((((uint16_t)sum)>>8)&0xff)|((((uint16_t)sum)<<8)&0xff00))); //здесь мы преобразовали к виду big endian и сделали побитовую инверсию
}

if (len) sum+=((uint32_t)*ptr)<<8;

uint16_t checksum(uint8_t *ptr, uint16_t len, uint8_t type)
{
    uint32_t sum = 0;
    
    if(type == 1) // это для UDP
    {
        sum+=IP_UDP;
        sum+=len-8;
    }   
                            
    while(len > 0)
    {
        sum += (uint16_t) (((uint32_t)*ptr<<8) |*(ptr+1));
        ptr+=2; //переходим еще на 16 бит 
        len-=2; //
    }
    if (len) sum+=((uint32_t)*ptr)<<8;
    while(sum>>16) sum = (uint16_t)sum+(sum>>16); 
    return ~be16toword((uint16_t)sum); //сдесь мы переобразовали к виду big endian и сделали побитовую инверсию
}

while(len > 0)

while(len)

 if (len) sum+=((uint32_t)*ptr)<<8;

while(len > 1)
    {
        sum += (uint16_t) (((uint32_t)*ptr<<8) |*(ptr+1));
        ptr+=2; //переходим еще на 16 бит 
        len-=2; //
    }

if (len) sum+=((uint32_t)*ptr)<<8;

sum += (uint16_t) (((uint32_t)*ptr<<8) |*(ptr+1));

sum += (uint16_t) ((uint32_t)*ptr |*(ptr+1) <<8);

 return ~be16toword((uint16_t)sum);

return ~((uint16_t)sum);

uint16_t ip_check_sum(uint16_t *buf, uint8_t len)
{
    uint32_t sum = 0;
    // Рассчитываем сумму word'ов блока
    while (len>1)
    {
        sum += *buf;
        buf ++;
        len -= 2;
    }
 
    if (len)            // если остался нечетный байт
        sum += (uint8_t)*buf;
 
    // Складываем старший и младший word суммы
    // пока не получим число, влезающее в word
    while (sum >> 16)
        sum = (sum & 0xffff) + (sum >> 16);
 
    //Берём дополнение до единицы
    return ~((uint16_t)sum);
}

/** \brief  Reverse byte order (16 bit)
 
    This function reverses the byte order in two unsigned short values.
 
    \param [in]    value  Value to reverse
    \return               Reversed value
 */
__attribute__( ( always_inline ) ) static __INLINE uint32_t __REV16(uint32_t value)
{
  uint32_t result;
 
  __ASM volatile ("rev16 %0, %1" : "=r" (result) : "r" (value) );
  return(result);
}