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