Browse Prior Art Database

Incremental updating of the Internet checksum (RFC1141) Disclosure Number: IPCOM000001952D
Original Publication Date: 1990-Jan-01
Included in the Prior Art Database: 2000-Sep-12
Document File: 2 page(s) / 3K

Publishing Venue

Internet Society Requests For Comment (RFCs)

Related People

T. Mallory: AUTHOR [+1]


Status of this Memo

This text was extracted from a ASCII document.
This is the abbreviated version, containing approximately 82% of the total text.

Network Working Group T. Mallory

Request for Comments: 1141 A. Kullberg

Obsoletes: RFC 1071 BBN Communications

January 1990

Incremental Updating of the Internet Checksum

Status of this Memo

This memo correctly describes the incremental update procedure for

use with the standard Internet checksum. It is intended to replace

the description of Incremental Update in RFC 1071. This is not a

standard but rather, an implementation technique. Distribution of

this memo is unlimited.


In RFC 1071 on pages 4 and 5, there is a description of a method to

update the IP checksum in the IP header without having to completely

recompute the checksum. In particular, the RFC recommends the

following equation for computing the update checksum C' from the

original checksum C, and the old and new values of byte m:

C' = C + (-m) + m' = C + (m' - m)

While the equation above is correct, it is not very useful for

incremental updates since the equation above updates the checksum C,

rather than the 1's complement of the checksum, ~C, which is the

value stored in the checksum field. In addition, it suffers because

the notation does not clearly specify that all arithmetic, including

the unary negation, must be performed one's complement, and so is

difficult to use to build working code. The useful calculation for

2's complement machines is:

~C' = ~(C + (-m) + m') = ~C + (m - m') = ~C + m + ~m'

In the oft-mentioned case of updating the IP TTL field, subtracting

one from the TTL means ADDING 1 or 256 as appropriate to the checksum

field in the packet, using one's complement addition. One big-endian

non-portable implementation in C looks like:

unsigned long sum;

ipptr->ttl--; /* decrement ttl */

sum = ipptr->Checksum + 0x100; /* increment checksum high byte*/

ipptr->Checksum = (sum + (sum>>16)) /* add carry */

This special case can be optimized in many ways: for instance, you

can bundle updating and checking the ttl. Compiler mileage may vary.

Here is a more general and possibly more helpful example which

updates the ttl by n seconds:


struct ip_hdr *ipptr;

unsigned char n;


unsigned long sum;

unsigned short old;

old = ntohs(*(unsigned short *)&ipptr->ttl);

ipptr->ttl -= n;

sum = old + (~ntohs(*(unsigned short *)&ipptr->ttl) & 0xffff);