unsigned short checksum1(const char *buf, unsigned size)

 {

     unsigned sum = ;

     int i;

     /* Accumulate checksum */

     for (i = ; i < size - ; i += )

     {

         unsigned short word16 = *(unsigned short *) &buf[i];

         sum += word16;

     }

     /* Handle odd-sized case */

     if (size & )

     {

         unsigned short word16 = (unsigned char) buf[i];

         sum += word16;

     }

     /* Fold to get the ones-complement result */

     while (sum >> ) sum = (sum & 0xFFFF)+(sum >> );

     /* Invert to get the negative in ones-complement arithmetic */

     return ~sum;

 }

 try:

     import dnet

     def in_cksum_add(s, buf):

         return dnet.ip_cksum_add(buf, s)

     def in_cksum_done(s):

         return socket.ntohs(dnet.ip_cksum_carry(s))

 except ImportError:

     import array

     def in_cksum_add(s, buf):

         n = len(buf)

         cnt = (n / 2) * 2

         a = array.array('H', buf[:cnt])

         if cnt != n:

             a.append(struct.unpack('H', buf[-1] + '\x00')[0])

         return s + sum(a)

     def in_cksum_done(s):

         s = (s >> 16) + (s & 0xffff)

         s += (s >> 16)

         return socket.ntohs(~s & 0xffff)

 /*

  * Checksum routine for Internet Protocol family headers (Portable Version).

  *

  * This routine is very heavily used in the network

  * code and should be modified for each CPU to be as fast as possible.

  */

 #define ADDCARRY(x)  {if ((x) > 65535) (x) -= 65535;}

 #define REDUCE {l_util.l = sum; sum = l_util.s[0] + l_util.s[1]; ADDCARRY(sum);}

 int

 in_cksum(const vec_t *vec, int veclen)

 {

     register const guint16 *w;

     register int sum = ;

     register int mlen = ;

     int byte_swapped = ;

     union {

         guint8    c[];

         guint16    s;

     } s_util;

     union {

         guint16 s[];

         guint32    l;

     } l_util;

     for (; veclen != ; vec++, veclen--) {

         if (vec->len == )

             continue;

         w = (const guint16 *)(const void *)vec->ptr;

         if (mlen == -) {

             /*

              * The first byte of this chunk is the continuation

              * of a word spanning between this chunk and the

              * last chunk.

              *

              * s_util.c[0] is already saved when scanning previous

              * chunk.

              */

             s_util.c[] = *(const guint8 *)w;

             sum += s_util.s;

             w = (const guint16 *)(const void *)((const guint8 *)w + );

             mlen = vec->len - ;

         } else

             mlen = vec->len;

         /*

          * Force to even boundary.

          */

         if (( & (unsigned long) w) && (mlen > )) {

             REDUCE;

             sum <<= ;

             s_util.c[] = *(const guint8 *)w;

             w = (const guint16 *)(const void *)((const guint8 *)w + );

             mlen--;

             byte_swapped = ;

         }

         /*

          * Unroll the loop to make overhead from

          * branches &c small.

          */

         while ((mlen -= ) >= ) {

             sum += w[]; sum += w[]; sum += w[]; sum += w[];

             sum += w[]; sum += w[]; sum += w[]; sum += w[];

             sum += w[]; sum += w[]; sum += w[]; sum += w[];

             sum += w[]; sum += w[]; sum += w[]; sum += w[];

             w += ;

         }

         mlen += ;

         while ((mlen -= ) >= ) {

             sum += w[]; sum += w[]; sum += w[]; sum += w[];

             w += ;

         }

         mlen += ;

         if (mlen ==  && byte_swapped == )

             continue;

         REDUCE;

         while ((mlen -= ) >= ) {

             sum += *w++;

         }

         if (byte_swapped) {

             REDUCE;

             sum <<= ;

             byte_swapped = ;

             if (mlen == -) {

                 s_util.c[] = *(const guint8 *)w;

                 sum += s_util.s;

                 mlen = ;

             } else

                 mlen = -;

         } else if (mlen == -)

             s_util.c[] = *(const guint8 *)w;

     }

     if (mlen == -) {

         /* The last mbuf has odd # of bytes. Follow the

            standard (the odd byte may be shifted left by 8 bits

            or not as determined by endian-ness of the machine) */

         s_util.c[] = ;

         sum += s_util.s;

     }

     REDUCE;

     return (~sum & 0xffff);

 }