Return to checksum.c CVS log

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

bird 1.6.3

    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: }