Return to checksum.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / lib

Annotation of embedaddon/bird/lib/checksum.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  *     BIRD Library -- IP One-Complement Checksum
        !             3:  *
        !             4:  *     (c) 1999--2000 Martin Mares <mj@ucw.cz>
        !             5:  *
        !             6:  *     Can be freely distributed and used under the terms of the GNU GPL.
        !             7:  */
        !             8: 
        !             9: /**
        !            10:  * DOC: Miscellaneous functions.
        !            11:  */
        !            12: 
        !            13: #include <stdarg.h>
        !            14: 
        !            15: #include "nest/bird.h"
        !            16: #include "checksum.h"
        !            17: 
        !            18: static inline u32
        !            19: add32(u32 sum, u32 x)
        !            20: {
        !            21:   u32 z = sum + x;
        !            22: //  return z + (z < sum);
        !            23: 
        !            24:  /* add carry */
        !            25:   if (z < x)
        !            26:     z++;
        !            27:   return z;
        !            28: }
        !            29: 
        !            30: static u16
        !            31: ipsum_calc_block(u32 *buf, uint len, u16 isum)
        !            32: {
        !            33:   /*
        !            34:    *  A few simple facts about the IP checksum (see RFC 1071 for detailed
        !            35:    *  discussion):
        !            36:    *
        !            37:    *   o  It's associative and commutative.
        !            38:    *   o  It's byte order independent.
        !            39:    *   o  It's word size independent.
        !            40:    *
        !            41:    *  This gives us a neat 32-bits-at-a-time algorithm which respects
        !            42:    *  usual alignment requirements and is reasonably fast.
        !            43:    */
        !            44: 
        !            45:   ASSERT(!(len % 4));
        !            46:   if (!len)
        !            47:     return isum;
        !            48: 
        !            49:   u32 *end = buf + (len >> 2);
        !            50:   u32 sum = isum;
        !            51:   while (buf < end)
        !            52:     sum = add32(sum, *buf++);
        !            53: 
        !            54:   sum = (sum >> 16) + (sum & 0xffff);    /* add high-16 to low-16 */
        !            55:   sum += (sum >> 16); /* add carry */
        !            56:   return sum;
        !            57: }
        !            58: 
        !            59: static u16
        !            60: ipsum_calc(void *frag, uint len, va_list args)
        !            61: {
        !            62:   u16 sum = 0;
        !            63: 
        !            64:   for(;;)
        !            65:     {
        !            66:       sum = ipsum_calc_block(frag, len, sum);
        !            67:       frag = va_arg(args, void *);
        !            68:       if (!frag)
        !            69:        break;
        !            70:       len = va_arg(args, uint);
        !            71:     }
        !            72:   return sum;
        !            73: }
        !            74: 
        !            75: /**
        !            76:  * ipsum_verify - verify an IP checksum
        !            77:  * @frag: first packet fragment
        !            78:  * @len: length in bytes
        !            79:  *
        !            80:  * This function verifies whether a given fragmented packet
        !            81:  * has correct one's complement checksum as used by the IP
        !            82:  * protocol.
        !            83:  *
        !            84:  * It uses all the clever tricks described in RFC 1071 to speed
        !            85:  * up checksum calculation as much as possible.
        !            86:  *
        !            87:  * Result: 1 if the checksum is correct, 0 else.
        !            88:  */
        !            89: int
        !            90: ipsum_verify(void *frag, uint len, ...)
        !            91: {
        !            92:   va_list args;
        !            93:   u16 sum;
        !            94: 
        !            95:   va_start(args, len);
        !            96:   sum = ipsum_calc(frag, len, args);
        !            97:   va_end(args);
        !            98:   return sum == 0xffff;
        !            99: }
        !           100: 
        !           101: /**
        !           102:  * ipsum_calculate - compute an IP checksum
        !           103:  * @frag: first packet fragment
        !           104:  * @len: length in bytes
        !           105:  *
        !           106:  * This function calculates a one's complement checksum of a given fragmented
        !           107:  * packet.
        !           108:  *
        !           109:  * It uses all the clever tricks described in RFC 1071 to speed
        !           110:  * up checksum calculation as much as possible.
        !           111:  */
        !           112: u16
        !           113: ipsum_calculate(void *frag, uint len, ...)
        !           114: {
        !           115:   va_list args;
        !           116:   u16 sum;
        !           117: 
        !           118:   va_start(args, len);
        !           119:   sum = ipsum_calc(frag, len, args);
        !           120:   va_end(args);
        !           121:   return 0xffff - sum;
        !           122: }