GENWiki

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.

Description

 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

Mallory & Kullberg [Page 1]  RFC 1141 Incremental Updating January 1990

 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:

    UpdateTTL(iph,n)
    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);
        sum += ntohs(ipptr->Checksum);
        sum = (sum & 0xffff) + (sum>>16);
        ipptr->Checksum = htons(sum + (sum>>16));
    }

Security Considerations

 Security issues are not addressed in this memo.

Authors' Addresses

 Tracy Mallory
 BBN Communications Corporation
 50 Moulton Street
 Cambridge, MA 02238

 Phone: (617) 873-3193

 EMail: tmallory@CCV.BBN.COM

 A. Kullberg
 BBN Communications Corporation
 50 Moulton Street
 Cambridge, MA 02238

 Phone: (617) 873-4000

 EMail:  akullberg@BBN.COM

Mallory & Kullberg [Page 2]