UDP CHECKSUM CALCULATION

UDP CHECKSUM CALCULATION

The checksum is calculated over all the octets of the pseudo header, UDP header and data.

If the data contains an odd number of octets a pad, zero octet is added to the end of data.

The pseudo header and the pad are not transmitted with the packet.

In the example code,

u16 buff[] is an array containing all the octets in the UDP header and data.

u16 len_udp is the length (number of octets) of the UDP header and data.

BOOL padding is 1 if data has an even number of octets and 0 for an odd number.

u16 src_addr[4] and u16 dest_addr[4] are the IP source and destination address octets

Function: udp_sum_calc()

Description: Calculate UDP checksum

typedef unsigned short u16;

typedef unsigned long u32;

u16 udp_sum_calc(u16 len_udp, u16 src_addr[],u16 dest_addr[], BOOL padding, u16 buff[])

{

u16 prot_udp=17;

u16 padd=0;

u16 word16;

u32 sum;         

           

            // Find out if the length of data is even or odd number. If odd,

            // add a padding byte = 0 at the end of packet

            if (padding&1==1){

                        padd=1;

                        buff[len_udp]=0;

            }

           

            //initialize sum to zero

            sum=0;

           

            // make 16 bit words out of every two adjacent 8 bit words and

            // calculate the sum of all 16 vit words

            for (i=0;i

                        word16 =((buff[i]<<8)&0xFF00)+(buff[i+1]&0xFF);

                        sum = sum + (unsigned long)word16;

            }         

            // add the UDP pseudo header which contains the IP source and destinationn addresses

            for (i=0;i<4;i=i+2){

                        word16 =((src_addr[i]<<8)&0xFF00)+(src_addr[i+1]&0xFF);

                        sum=sum+word16;    

            }

            for (i=0;i<4;i=i+2){

                        word16 =((dest_addr[i]<<8)&0xFF00)+(dest_addr[i+1]&0xFF);

                        sum=sum+word16;    

            }

            // the protocol number and the length of the UDP packet

            sum = sum + prot_udp + len_udp;

            // keep only the last 16 bits of the 32 bit calculated sum and add the carries

            while (sum>>16)

                        sum = (sum & 0xFFFF)+(sum >> 16);

                       

            // Take the one's complement of sum

            sum = ~sum;

return ((u16) sum);

}

Here we give a simple example of the checksum calculation. You can find details about efficient implementation of the calculation in the [RFC 1071]. As an example, suppose that we have the following three 16-bit words:

0110011001100110

0101010101010101

0000111100001111

The sum of first of these 16-bit words is:

0110011001100110

0101010101010101

---------------------

1011101110111011

Adding the third word to the above sum gives

1011101110111011

0000111100001111

---------------------

1100101011001010

The 1's complement is obtained by converting all the 0s to 1s and converting all the 1s to 0s. Thus the 1's complement of the sum 1100101011001010 is 0011010100110101, which becomes the checksum. At the receiver, all four 16-bit words are added, including the checksum. If no errors are introduced into the segment, then clearly the sum at the receiver will be 1111111111111111. If one of the bits is a zero, then we know that errors have been introduced into the segment. In section 5.1, we'll see that the Internet checksum is not foolproof -- even if the sum equals 111111111111111, it is still possible that there are undetected errors in the segment.  For this reason, a number of protocols use more sophisticated error detection techniques than simple check summing.

Notice that this does not equate to making the number of 1's even or odd

0110011001100110

0101010101010101

0000111100001111

0011010100110101

----------------

EEEEOEEOEEEEOEEO