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.
8 * Copyright (c) 1988, 1992, 1993
9 * The Regents of the University of California. All rights reserved.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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
35 * @(#)in_cksum.c 8.1 (Berkeley) 6/10/93
42 #include <netdissect-stdinc.h>
44 #include "netdissect.h"
47 * Checksum routine for Internet Protocol family headers (Portable Version).
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.
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);}
57 in_cksum(const struct cksum_vec
*vec
, int veclen
)
59 register const uint16_t *w
;
61 register int mlen
= 0;
73 for (; veclen
!= 0; vec
++, veclen
--) {
76 w
= (const uint16_t *)(const void *)vec
->ptr
;
79 * The first byte of this chunk is the continuation
80 * of a word spanning between this chunk and the
83 * s_util.c[0] is already saved when scanning previous
86 s_util
.c
[1] = *(const uint8_t *)w
;
88 w
= (const uint16_t *)(const void *)((const uint8_t *)w
+ 1);
93 * Force to even boundary.
95 if ((1 & (uintptr_t) w
) && (mlen
> 0)) {
98 s_util
.c
[0] = *(const uint8_t *)w
;
99 w
= (const uint16_t *)(const void *)((const uint8_t *)w
+ 1);
104 * Unroll the loop to make overhead from
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];
115 while ((mlen
-= 8) >= 0) {
116 sum
+= w
[0]; sum
+= w
[1]; sum
+= w
[2]; sum
+= w
[3];
120 if (mlen
== 0 && byte_swapped
== 0)
123 while ((mlen
-= 2) >= 0) {
131 s_util
.c
[1] = *(const uint8_t *)w
;
136 } else if (mlen
== -1)
137 s_util
.c
[0] = *(const uint8_t *)w
;
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) */
147 return (~sum
& 0xffff);
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.
157 in_cksum_shouldbe(uint16_t sum
, uint16_t computed_sum
)
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.
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.
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).
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.
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
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.
196 shouldbe
+= ntohs(computed_sum
);
197 shouldbe
= (shouldbe
& 0xFFFF) + (shouldbe
>> 16);
198 shouldbe
= (shouldbe
& 0xFFFF) + (shouldbe
>> 16);