lib/checksum.c

   1 /*
   2  * Checksum routine for Internet Protocol family headers (C Version).
   3  *
   4  * Refer to "Computing the Internet Checksum" by R. Braden, D. Borman and
   5  * C. Partridge, Computer Communication Review, Vol. 19, No. 2, April 1989,
   6  * pp. 86-101, for additional details on computing this checksum.
   7  */
   8
   9 #include <zebra.h>
  10 #include "checksum.h"
  11
  12 int                     /* return checksum in low-order 16 bits */
  13 in_cksum(void *parg, int nbytes)
  14 {
  15         u_short *ptr = parg;
  16         register long           sum;            /* assumes long == 32 bits */
  17         u_short                 oddbyte;
  18         register u_short        answer;         /* assumes u_short == 16 bits */
  19
  20         /*
  21          * Our algorithm is simple, using a 32-bit accumulator (sum),
  22          * we add sequential 16-bit words to it, and at the end, fold back
  23          * all the carry bits from the top 16 bits into the lower 16 bits.
  24          */
  25
  26         sum = 0;
  27         while (nbytes > 1)  {
  28                 sum += *ptr++;
  29                 nbytes -= 2;
  30         }
  31
  32                                 /* mop up an odd byte, if necessary */
  33         if (nbytes == 1) {
  34                 oddbyte = 0;            /* make sure top half is zero */
  35                 *((u_char *) &oddbyte) = *(u_char *)ptr;   /* one byte only */
  36                 sum += oddbyte;
  37         }
  38
  39         /*
  40          * Add back carry outs from top 16 bits to low 16 bits.
  41          */
  42
  43         sum  = (sum >> 16) + (sum & 0xffff);    /* add high-16 to low-16 */
  44         sum += (sum >> 16);                     /* add carry */
  45         answer = ~sum;          /* ones-complement, then truncate to 16 bits */
  46         return(answer);
  47 }
  48
  49 /* Fletcher Checksum -- Refer to RFC1008. */
  50 #define MODX                 4102   /* 5802 should be fine */
  51
  52 /* To be consistent, offset is 0-based index, rather than the 1-based
  53    index required in the specification ISO 8473, Annex C.1 */
  54 /* calling with offset == FLETCHER_CHECKSUM_VALIDATE will validate the checksum
  55    without modifying the buffer; a valid checksum returns 0 */
  56 u_int16_t
  57 fletcher_checksum(u_char * buffer, const size_t len, const uint16_t offset)
  58 {
  59   u_int8_t *p;
  60   int x, y, c0, c1;
  61   u_int16_t checksum;
  62   u_int16_t *csum;
  63   size_t partial_len, i, left = len;
  64
  65   checksum = 0;
  66
  67
  68   if (offset != FLETCHER_CHECKSUM_VALIDATE)
  69     /* Zero the csum in the packet. */
  70     {
  71       assert (offset < (len - 1)); /* account for two bytes of checksum */
  72       csum = (u_int16_t *) (buffer + offset);
  73       *(csum) = 0;
  74     }
  75
  76   p = buffer;
  77   c0 = 0;
  78   c1 = 0;
  79
  80   while (left != 0)
  81     {
  82       partial_len = MIN(left, MODX);
  83
  84       for (i = 0; i < partial_len; i++)
  85         {
  86           c0 = c0 + *(p++);
  87           c1 += c0;
  88         }
  89
  90       c0 = c0 % 255;
  91       c1 = c1 % 255;
  92
  93       left -= partial_len;
  94     }
  95
  96   /* The cast is important, to ensure the mod is taken as a signed value. */
  97   x = (int)((len - offset - 1) * c0 - c1) % 255;
  98
  99   if (x <= 0)
 100     x += 255;
 101   y = 510 - c0 - x;
 102   if (y > 255)
 103     y -= 255;
 104
 105   if (offset == FLETCHER_CHECKSUM_VALIDATE)
 106     {
 107       checksum = (c1 << 8) + c0;
 108     }
 109   else
 110     {
 111       /*
 112        * Now we write this to the packet.
 113        * We could skip this step too, since the checksum returned would
 114        * be stored into the checksum field by the caller.
 115        */
 116       buffer[offset] = x;
 117       buffer[offset + 1] = y;
 118
 119       /* Take care of the endian issue */
 120       checksum = htons((x << 8) | (y & 0xFF));
 121     }
 122
 123   return checksum;
 124 }