Return to checksum.c CVS log

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

Annotation of embedaddon/quagga/lib/checksum.c, revision 1.1.1.2

1.1       misho       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 */
1.1.1.2 ! misho      54: /* calling with offset == FLETCHER_CHECKSUM_VALIDATE will validate the checksum
        !            55:    without modifying the buffer; a valid checksum returns 0 */
1.1       misho      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: 
1.1.1.2 ! misho      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:     }
1.1       misho      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:     }
1.1.1.2 ! misho      95: 
1.1       misho      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: 
1.1.1.2 ! misho     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:     }
1.1       misho     122: 
                    123:   return checksum;
                    124: }