Home | History | Annotate | Download | only in tcpdump
      1 /* in_cksum.c
      2  * 4.4-Lite-2 Internet checksum routine, modified to take a vector of
      3  * pointers/lengths giving the pieces to be checksummed.  Also using
      4  * Tahoe/CGI version of ADDCARRY(x) macro instead of from portable version.
      5  */
      6 
      7 /*
      8  * Copyright (c) 1988, 1992, 1993
      9  *	The Regents of the University of California.  All rights reserved.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions and the following disclaimer.
     16  * 2. Redistributions in binary form must reproduce the above copyright
     17  *    notice, this list of conditions and the following disclaimer in the
     18  *    documentation and/or other materials provided with the distribution.
     19  * 3. Neither the name of the University nor the names of its contributors
     20  *    may be used to endorse or promote products derived from this software
     21  *    without specific prior written permission.
     22  *
     23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  * SUCH DAMAGE.
     34  *
     35  *	@(#)in_cksum.c	8.1 (Berkeley) 6/10/93
     36  */
     37 
     38 #ifdef HAVE_CONFIG_H
     39 # include "config.h"
     40 #endif
     41 
     42 #include <tcpdump-stdinc.h>
     43 
     44 #include "interface.h"
     45 
     46 /*
     47  * Checksum routine for Internet Protocol family headers (Portable Version).
     48  *
     49  * This routine is very heavily used in the network
     50  * code and should be modified for each CPU to be as fast as possible.
     51  */
     52 
     53 #define ADDCARRY(x)  {if ((x) > 65535) (x) -= 65535;}
     54 #define REDUCE {l_util.l = sum; sum = l_util.s[0] + l_util.s[1]; ADDCARRY(sum);}
     55 
     56 u_int16_t
     57 in_cksum(const struct cksum_vec *vec, int veclen)
     58 {
     59 	register const u_int16_t *w;
     60 	register int sum = 0;
     61 	register int mlen = 0;
     62 	int byte_swapped = 0;
     63 
     64 	union {
     65 		u_int8_t	c[2];
     66 		u_int16_t	s;
     67 	} s_util;
     68 	union {
     69 		u_int16_t	s[2];
     70 		u_int32_t	l;
     71 	} l_util;
     72 
     73 	for (; veclen != 0; vec++, veclen--) {
     74 		if (vec->len == 0)
     75 			continue;
     76 		w = (const u_int16_t *)(void *)vec->ptr;
     77 		if (mlen == -1) {
     78 			/*
     79 			 * The first byte of this chunk is the continuation
     80 			 * of a word spanning between this chunk and the
     81 			 * last chunk.
     82 			 *
     83 			 * s_util.c[0] is already saved when scanning previous
     84 			 * chunk.
     85 			 */
     86 			s_util.c[1] = *(const u_int8_t *)w;
     87 			sum += s_util.s;
     88 			w = (const u_int16_t *)(void *)((const u_int8_t *)w + 1);
     89 			mlen = vec->len - 1;
     90 		} else
     91 			mlen = vec->len;
     92 		/*
     93 		 * Force to even boundary.
     94 		 */
     95 		if ((1 & (unsigned long) w) && (mlen > 0)) {
     96 			REDUCE;
     97 			sum <<= 8;
     98 			s_util.c[0] = *(const u_int8_t *)w;
     99 			w = (const u_int16_t *)(void *)((const u_int8_t *)w + 1);
    100 			mlen--;
    101 			byte_swapped = 1;
    102 		}
    103 		/*
    104 		 * Unroll the loop to make overhead from
    105 		 * branches &c small.
    106 		 */
    107 		while ((mlen -= 32) >= 0) {
    108 			sum += w[0]; sum += w[1]; sum += w[2]; sum += w[3];
    109 			sum += w[4]; sum += w[5]; sum += w[6]; sum += w[7];
    110 			sum += w[8]; sum += w[9]; sum += w[10]; sum += w[11];
    111 			sum += w[12]; sum += w[13]; sum += w[14]; sum += w[15];
    112 			w += 16;
    113 		}
    114 		mlen += 32;
    115 		while ((mlen -= 8) >= 0) {
    116 			sum += w[0]; sum += w[1]; sum += w[2]; sum += w[3];
    117 			w += 4;
    118 		}
    119 		mlen += 8;
    120 		if (mlen == 0 && byte_swapped == 0)
    121 			continue;
    122 		REDUCE;
    123 		while ((mlen -= 2) >= 0) {
    124 			sum += *w++;
    125 		}
    126 		if (byte_swapped) {
    127 			REDUCE;
    128 			sum <<= 8;
    129 			byte_swapped = 0;
    130 			if (mlen == -1) {
    131 				s_util.c[1] = *(const u_int8_t *)w;
    132 				sum += s_util.s;
    133 				mlen = 0;
    134 			} else
    135 				mlen = -1;
    136 		} else if (mlen == -1)
    137 			s_util.c[0] = *(const u_int8_t *)w;
    138 	}
    139 	if (mlen == -1) {
    140 		/* The last mbuf has odd # of bytes. Follow the
    141 		   standard (the odd byte may be shifted left by 8 bits
    142 		   or not as determined by endian-ness of the machine) */
    143 		s_util.c[1] = 0;
    144 		sum += s_util.s;
    145 	}
    146 	REDUCE;
    147 	return (~sum & 0xffff);
    148 }
    149 
    150 /*
    151  * Given the host-byte-order value of the checksum field in a packet
    152  * header, and the network-byte-order computed checksum of the data
    153  * that the checksum covers (including the checksum itself), compute
    154  * what the checksum field *should* have been.
    155  */
    156 u_int16_t
    157 in_cksum_shouldbe(u_int16_t sum, u_int16_t computed_sum)
    158 {
    159 	u_int32_t shouldbe;
    160 
    161 	/*
    162 	 * The value that should have gone into the checksum field
    163 	 * is the negative of the value gotten by summing up everything
    164 	 * *but* the checksum field.
    165 	 *
    166 	 * We can compute that by subtracting the value of the checksum
    167 	 * field from the sum of all the data in the packet, and then
    168 	 * computing the negative of that value.
    169 	 *
    170 	 * "sum" is the value of the checksum field, and "computed_sum"
    171 	 * is the negative of the sum of all the data in the packets,
    172 	 * so that's -(-computed_sum - sum), or (sum + computed_sum).
    173 	 *
    174 	 * All the arithmetic in question is one's complement, so the
    175 	 * addition must include an end-around carry; we do this by
    176 	 * doing the arithmetic in 32 bits (with no sign-extension),
    177 	 * and then adding the upper 16 bits of the sum, which contain
    178 	 * the carry, to the lower 16 bits of the sum, and then do it
    179 	 * again in case *that* sum produced a carry.
    180 	 *
    181 	 * As RFC 1071 notes, the checksum can be computed without
    182 	 * byte-swapping the 16-bit words; summing 16-bit words
    183 	 * on a big-endian machine gives a big-endian checksum, which
    184 	 * can be directly stuffed into the big-endian checksum fields
    185 	 * in protocol headers, and summing words on a little-endian
    186 	 * machine gives a little-endian checksum, which must be
    187 	 * byte-swapped before being stuffed into a big-endian checksum
    188 	 * field.
    189 	 *
    190 	 * "computed_sum" is a network-byte-order value, so we must put
    191 	 * it in host byte order before subtracting it from the
    192 	 * host-byte-order value from the header; the adjusted checksum
    193 	 * will be in host byte order, which is what we'll return.
    194 	 */
    195 	shouldbe = sum;
    196 	shouldbe += ntohs(computed_sum);
    197 	shouldbe = (shouldbe & 0xFFFF) + (shouldbe >> 16);
    198 	shouldbe = (shouldbe & 0xFFFF) + (shouldbe >> 16);
    199 	return shouldbe;
    200 }
    201