UDP checksum error c++
I am calculating UDP checksum using the following function (found it somewhere):
uint16_t udp_checksum(const void *buff, size_t len, in_addr_t src_addr, in_addr_t dest_addr)
{
const uint16_t *buf=(const uint16_t *)buff;
uint16_t *ip_src=(uint16_t *)&src_addr,
*ip_dst=(uint16_t *)&dest_addr;
uint32_t sum;
size_t length=len;
// Calculate the sum
sum = 0;
while (len > 1)
{
sum += *buf++;
if (sum & 0x80000000)
sum = (sum & 0xFFFF) + (sum >> 16);
len -= 2;
}
if ( len & 1 )
// Add the padding if the packet length is odd
sum += *((uint8_t *)buf);
// Add the pseudo-header
sum += *(ip_src++);
sum += *ip_src;
sum += *(ip_dst++);
sum += *ip_dst;
sum += htons(IPROTO_UDP);
sum += htons(length);
// Add the carries
while (sum >> 16)
sum = (sum & 0xFFFF) + (sum >> 16);
// Return the one's complement of sum
return ( (uint16_t)(~sum) );
}
int form_checksums(char * buff)
{
// Get IP and UDP headers
IP_Header* ipHdr = (IP_Header*)(buff);
struct UDP_Header* udpHdr = (struct UDP_Header*) (buff + 4*ipHdr->ihl);
//---- Form and fill IP checksum now--------------------------------------
ipHdr->check = 0;
ipHdr->check = in_cksum((unsigned short *)ipHdr, sizeof(*ipHdr));
//---- calculate and fill udp checksum now ---
ud开发者_运维百科pHdr->checksum = 0;
udpHdr->checksum = udp_checksum(buff + 4*ipHdr->ihl, udpHdr->length, ipHdr->saddr, ipHdr->daddr);
return 0;
}
Wireshark shows that the wrong UDP checksum is calculated. I don't see any problem in the function. What can be going wrong?
UDP checksum computation requires an UDP pseudo-header.
Here are some code samples from my libraries that might help:
// SmartBuffer is a stream-like buffer class
uint16_t SmartBuffer::checksum(const void* buf, size_t buflen)
{
assert(buf);
uint32_t r = 0;
size_t len = buflen;
const uint16_t* d = reinterpret_cast<const uint16_t*>(buf);
while (len > 1)
{
r += *d++;
len -= sizeof(uint16_t);
}
if (len)
{
r += *reinterpret_cast<const uint8_t*>(d);
}
while (r >> 16)
{
r = (r & 0xffff) + (r >> 16);
}
return static_cast<uint16_t>(~r);
}
The UDPFrame
checksum computing:
uint16_t UDPFrame::computeChecksum(const ipv4_header& ih) const
{
udp_pseudo_header uph;
memset(&uph, 0x00, sizeof(uph));
uph.source = ih.source;
uph.destination = ih.destination;
uph.mbz = 0x00;
uph.type = ih.protocol;
uph.length = getData()->length;
systools::SmartBuffer tmp(sizeof(uph) + d_data.size());
tmp.appendValue(uph);
tmp.append(d_data); // d_data is the UDP frame payload
return tmp.checksum();
}
Anyway, keep in mind that usually wireshark warns you that a wrong value for the checksum can be computed due to UDP checksum offload.
Perhaps your checksum function is indeed wrong but a reliable way of beeing sure is to try to receive your UDP frames.
The UDP checksum is usually calculated using a UDP pseudo header. This includes a protocol id (17) already in network order. I think you must replace the sum = htons(17)
by sum += 17
.
In my case, it was not working well because I was not filling correctly source and destination address arguments (endianess issues), but the function works well as posted in this question. You must set checksum to 0xFFFF if the function returns zero.
精彩评论