1/** 2 * @file 3 * Incluse internet checksum functions. 4 * 5 */ 6 7/* 8 * Copyright (c) 2001-2004 Swedish Institute of Computer Science. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without modification, 12 * are permitted provided that the following conditions are met: 13 * 14 * 1. Redistributions of source code must retain the above copyright notice, 15 * this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright notice, 17 * this list of conditions and the following disclaimer in the documentation 18 * and/or other materials provided with the distribution. 19 * 3. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 23 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 24 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 25 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 26 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 27 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 30 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 31 * OF SUCH DAMAGE. 32 * 33 * This file is part of the lwIP TCP/IP stack. 34 * 35 * Author: Adam Dunkels <adam@sics.se> 36 * 37 */ 38 39#include "lwip/opt.h" 40 41#include "lwip/inet_chksum.h" 42#include "lwip/inet.h" 43 44#include <stddef.h> 45 46/* These are some reference implementations of the checksum algorithm, with the 47 * aim of being simple, correct and fully portable. Checksumming is the 48 * first thing you would want to optimize for your platform. If you create 49 * your own version, link it in and in your cc.h put: 50 * 51 * #define LWIP_CHKSUM <your_checksum_routine> 52 * 53 * Or you can select from the implementations below by defining 54 * LWIP_CHKSUM_ALGORITHM to 1, 2 or 3. 55 */ 56 57#ifndef LWIP_CHKSUM 58#define LWIP_CHKSUM lwip_standard_chksum 59#ifndef LWIP_CHKSUM_ALGORITHM 60#define LWIP_CHKSUM_ALGORITHM 1 61#endif 62#endif 63/* If none set: */ 64#ifndef LWIP_CHKSUM_ALGORITHM 65#define LWIP_CHKSUM_ALGORITHM 0 66#endif 67 68/** Like the name says... */ 69#if LWIP_PLATFORM_BYTESWAP && (BYTE_ORDER == LITTLE_ENDIAN) 70/* little endian and PLATFORM_BYTESWAP defined */ 71#define SWAP_BYTES_IN_WORD(w) LWIP_PLATFORM_HTONS(w) 72#else 73/* can't use htons on big endian (or PLATFORM_BYTESWAP not defined)... */ 74#define SWAP_BYTES_IN_WORD(w) ((w & 0xff) << 8) | ((w & 0xff00) >> 8) 75#endif 76 77/** Split an u32_t in two u16_ts and add them up */ 78#define FOLD_U32T(u) ((u >> 16) + (u & 0x0000ffffUL)) 79 80#if (LWIP_CHKSUM_ALGORITHM == 1) /* Version #1 */ 81/** 82 * lwip checksum 83 * 84 * @param dataptr points to start of data to be summed at any boundary 85 * @param len length of data to be summed 86 * @return host order (!) lwip checksum (non-inverted Internet sum) 87 * 88 * @note accumulator size limits summable length to 64k 89 * @note host endianess is irrelevant (p3 RFC1071) 90 */ 91static u16_t lwip_standard_chksum(void *dataptr, u16_t len) 92{ 93 u32_t acc; 94 u16_t src; 95 u8_t *octetptr; 96 97 acc = 0; 98 /* dataptr may be at odd or even addresses */ 99 octetptr = (u8_t *) dataptr; 100 while (len > 1) { 101 /* declare first octet as most significant 102 thus assume network order, ignoring host order */ 103 src = (*octetptr) << 8; 104 octetptr++; 105 /* declare second octet as least significant */ 106 src |= (*octetptr); 107 octetptr++; 108 acc += src; 109 len -= 2; 110 } 111 if (len > 0) { 112 /* accumulate remaining octet */ 113 src = (*octetptr) << 8; 114 acc += src; 115 } 116 /* add deferred carry bits */ 117 acc = (acc >> 16) + (acc & 0x0000ffffUL); 118 if ((acc & 0xffff0000UL) != 0) { 119 acc = (acc >> 16) + (acc & 0x0000ffffUL); 120 } 121 /* This maybe a little confusing: reorder sum using htons() 122 instead of ntohs() since it has a little less call overhead. 123 The caller must invert bits for Internet sum ! */ 124 return htons((u16_t) acc); 125} 126#endif 127 128#if (LWIP_CHKSUM_ALGORITHM == 2) /* Alternative version #2 */ 129/* 130 * Curt McDowell 131 * Broadcom Corp. 132 * csm@broadcom.com 133 * 134 * IP checksum two bytes at a time with support for 135 * unaligned buffer. 136 * Works for len up to and including 0x20000. 137 * by Curt McDowell, Broadcom Corp. 12/08/2005 138 * 139 * @param dataptr points to start of data to be summed at any boundary 140 * @param len length of data to be summed 141 * @return host order (!) lwip checksum (non-inverted Internet sum) 142 */ 143 144static u16_t lwip_standard_chksum(void *dataptr, int len) 145{ 146 u8_t *pb = dataptr; 147 u16_t *ps, t = 0; 148 u32_t sum = 0; 149 int odd = ((u32_t) pb & 1); 150 151 /* Get aligned to u16_t */ 152 if (odd && len > 0) { 153 ((u8_t *) & t)[1] = *pb++; 154 len--; 155 } 156 157 /* Add the bulk of the data */ 158 ps = (u16_t *) pb; 159 while (len > 1) { 160 sum += *ps++; 161 len -= 2; 162 } 163 164 /* Consume left-over byte, if any */ 165 if (len > 0) { 166 ((u8_t *) & t)[0] = *(u8_t *) ps;; 167 } 168 169 /* Add end bytes */ 170 sum += t; 171 172 /* Fold 32-bit sum to 16 bits 173 calling this twice is propably faster than if statements... */ 174 sum = FOLD_U32T(sum); 175 sum = FOLD_U32T(sum); 176 177 /* Swap if alignment was odd */ 178 if (odd) { 179 sum = SWAP_BYTES_IN_WORD(sum); 180 } 181 182 return sum; 183} 184#endif 185 186#if (LWIP_CHKSUM_ALGORITHM == 3) /* Alternative version #3 */ 187/** 188 * An optimized checksum routine. Basically, it uses loop-unrolling on 189 * the checksum loop, treating the head and tail bytes specially, whereas 190 * the inner loop acts on 8 bytes at a time. 191 * 192 * @arg start of buffer to be checksummed. May be an odd byte address. 193 * @len number of bytes in the buffer to be checksummed. 194 * @return host order (!) lwip checksum (non-inverted Internet sum) 195 * 196 * by Curt McDowell, Broadcom Corp. December 8th, 2005 197 */ 198 199static u16_t lwip_standard_chksum(void *dataptr, int len) 200{ 201 u8_t *pb = dataptr; 202 u16_t *ps, t = 0; 203 u32_t *pl; 204 u32_t sum = 0, tmp; 205 206 /* starts at odd byte address? */ 207 int odd = ((u32_t) pb & 1); 208 209 if (odd && len > 0) { 210 ((u8_t *) & t)[1] = *pb++; 211 len--; 212 } 213 214 ps = (u16_t *) pb; 215 216 if (((u32_t) ps & 3) && len > 1) { 217 sum += *ps++; 218 len -= 2; 219 } 220 221 pl = (u32_t *) ps; 222 223 while (len > 7) { 224 tmp = sum + *pl++; /* ping */ 225 if (tmp < sum) { 226 tmp++; /* add back carry */ 227 } 228 229 sum = tmp + *pl++; /* pong */ 230 if (sum < tmp) { 231 sum++; /* add back carry */ 232 } 233 234 len -= 8; 235 } 236 237 /* make room in upper bits */ 238 sum = FOLD_U32T(sum); 239 240 ps = (u16_t *) pl; 241 242 /* 16-bit aligned word remaining? */ 243 while (len > 1) { 244 sum += *ps++; 245 len -= 2; 246 } 247 248 /* dangling tail byte remaining? */ 249 if (len > 0) { /* include odd byte */ 250 ((u8_t *) & t)[0] = *(u8_t *) ps; 251 } 252 253 sum += t; /* add end bytes */ 254 255 /* Fold 32-bit sum to 16 bits 256 calling this twice is propably faster than if statements... */ 257 sum = FOLD_U32T(sum); 258 sum = FOLD_U32T(sum); 259 260 if (odd) { 261 sum = SWAP_BYTES_IN_WORD(sum); 262 } 263 264 return sum; 265} 266#endif 267 268/* inet_chksum_pseudo: 269 * 270 * Calculates the pseudo Internet checksum used by TCP and UDP for a pbuf chain. 271 * IP addresses are expected to be in network byte order. 272 * 273 * @param p chain of pbufs over that a checksum should be calculated (ip data part) 274 * @param src source ip address (used for checksum of pseudo header) 275 * @param dst destination ip address (used for checksum of pseudo header) 276 * @param proto ip protocol (used for checksum of pseudo header) 277 * @param proto_len length of the ip data part (used for checksum of pseudo header) 278 * @return checksum (as u16_t) to be saved directly in the protocol header 279 */ 280u16_t 281inet_chksum_pseudo(struct pbuf * p, 282 struct ip_addr * src, struct ip_addr * dest, 283 u8_t proto, u16_t proto_len) 284{ 285 u32_t acc; 286 struct pbuf *q; 287 u8_t swapped; 288 289 acc = 0; 290 swapped = 0; 291 /* iterate through all pbuf in chain */ 292 for (q = p; q != NULL; q = q->next) { 293 LWIP_DEBUGF(INET_DEBUG, 294 ("inet_chksum_pseudo(): checksumming pbuf %p (has next %p) \n", 295 (void *) q, (void *) q->next)); 296 acc += LWIP_CHKSUM(q->payload, q->len); 297 /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc)); */ 298 /* just executing this next line is probably faster that the if statement needed 299 to check whether we really need to execute it, and does no harm */ 300 acc = FOLD_U32T(acc); 301 if (q->len % 2 != 0) { 302 swapped = 1 - swapped; 303 acc = SWAP_BYTES_IN_WORD(acc); 304 } 305 /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc)); */ 306 } 307 308 if (swapped) { 309 acc = SWAP_BYTES_IN_WORD(acc); 310 } 311 acc += (src->addr & 0xffffUL); 312 acc += ((src->addr >> 16) & 0xffffUL); 313 acc += (dest->addr & 0xffffUL); 314 acc += ((dest->addr >> 16) & 0xffffUL); 315 acc += (u32_t) htons((u16_t) proto); 316 acc += (u32_t) htons(proto_len); 317 318 /* Fold 32-bit sum to 16 bits 319 calling this twice is propably faster than if statements... */ 320 acc = FOLD_U32T(acc); 321 acc = FOLD_U32T(acc); 322 LWIP_DEBUGF(INET_DEBUG, 323 ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%" X32_F "\n", 324 acc)); 325 return (u16_t) ~ (acc & 0xffffUL); 326} 327 328/* inet_chksum_pseudo: 329 * 330 * Calculates the pseudo Internet checksum used by TCP and UDP for a pbuf chain. 331 * IP addresses are expected to be in network byte order. 332 * 333 * @param p chain of pbufs over that a checksum should be calculated (ip data part) 334 * @param src source ip address (used for checksum of pseudo header) 335 * @param dst destination ip address (used for checksum of pseudo header) 336 * @param proto ip protocol (used for checksum of pseudo header) 337 * @param proto_len length of the ip data part (used for checksum of pseudo header) 338 * @return checksum (as u16_t) to be saved directly in the protocol header 339 */ 340u16_t 341inet_chksum_pseudo_partial(struct pbuf * p, 342 struct ip_addr * src, struct ip_addr * dest, 343 u8_t proto, u16_t proto_len, u16_t chksum_len) 344{ 345 u32_t acc; 346 struct pbuf *q; 347 u8_t swapped; 348 u16_t chklen; 349 350 acc = 0; 351 swapped = 0; 352 /* iterate through all pbuf in chain */ 353 for (q = p; (q != NULL) && (chksum_len > 0); q = q->next) { 354 LWIP_DEBUGF(INET_DEBUG, 355 ("inet_chksum_pseudo(): checksumming pbuf %p (has next %p) \n", 356 (void *) q, (void *) q->next)); 357 chklen = q->len; 358 if (chklen > chksum_len) { 359 chklen = chksum_len; 360 } 361 acc += LWIP_CHKSUM(q->payload, chklen); 362 chksum_len -= chklen; 363 LWIP_ASSERT("delete me", chksum_len < 0x7fff); 364 /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc)); */ 365 /* fold the upper bit down */ 366 acc = FOLD_U32T(acc); 367 if (q->len % 2 != 0) { 368 swapped = 1 - swapped; 369 acc = SWAP_BYTES_IN_WORD(acc); 370 } 371 /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc)); */ 372 } 373 374 if (swapped) { 375 acc = SWAP_BYTES_IN_WORD(acc); 376 } 377 acc += (src->addr & 0xffffUL); 378 acc += ((src->addr >> 16) & 0xffffUL); 379 acc += (dest->addr & 0xffffUL); 380 acc += ((dest->addr >> 16) & 0xffffUL); 381 acc += (u32_t) htons((u16_t) proto); 382 acc += (u32_t) htons(proto_len); 383 384 /* Fold 32-bit sum to 16 bits 385 calling this twice is propably faster than if statements... */ 386 acc = FOLD_U32T(acc); 387 acc = FOLD_U32T(acc); 388 LWIP_DEBUGF(INET_DEBUG, 389 ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%" X32_F "\n", 390 acc)); 391 return (u16_t) ~ (acc & 0xffffUL); 392} 393 394/* inet_chksum: 395 * 396 * Calculates the Internet checksum over a portion of memory. Used primarily for IP 397 * and ICMP. 398 * 399 * @param dataptr start of the buffer to calculate the checksum (no alignment needed) 400 * @param len length of the buffer to calculate the checksum 401 * @return checksum (as u16_t) to be saved directly in the protocol header 402 */ 403 404u16_t inet_chksum(void *dataptr, u16_t len) 405{ 406 return ~LWIP_CHKSUM(dataptr, len); 407} 408 409/** 410 * Calculate a checksum over a chain of pbufs (without pseudo-header, much like 411 * inet_chksum only pbufs are used). 412 * 413 * @param p pbuf chain over that the checksum should be calculated 414 * @return checksum (as u16_t) to be saved directly in the protocol header 415 */ 416u16_t inet_chksum_pbuf(struct pbuf * p) 417{ 418 u32_t acc; 419 struct pbuf *q; 420 u8_t swapped; 421 422 acc = 0; 423 swapped = 0; 424 for (q = p; q != NULL; q = q->next) { 425 acc += LWIP_CHKSUM(q->payload, q->len); 426 acc = FOLD_U32T(acc); 427 if (q->len % 2 != 0) { 428 swapped = 1 - swapped; 429 acc = SWAP_BYTES_IN_WORD(acc); 430 } 431 } 432 433 if (swapped) { 434 acc = SWAP_BYTES_IN_WORD(acc); 435 } 436 return (u16_t) ~ (acc & 0xffffUL); 437} 438