2
* Copyright (c) 2001-2004 Swedish Institute of Computer Science.
5
* Redistribution and use in source and binary forms, with or without modification,
6
* are permitted provided that the following conditions are met:
8
* 1. Redistributions of source code must retain the above copyright notice,
9
* this list of conditions and the following disclaimer.
10
* 2. Redistributions in binary form must reproduce the above copyright notice,
11
* this list of conditions and the following disclaimer in the documentation
12
* and/or other materials provided with the distribution.
13
* 3. The name of the author may not be used to endorse or promote products
14
* derived from this software without specific prior written permission.
16
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
19
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
21
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
24
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
27
* This file is part of the lwIP TCP/IP stack.
29
* Author: Adam Dunkels <adam@sics.se>
36
* Functions common to all TCP/IP modules, such as the Internet checksum and the
37
* byte order functions.
44
#include "lwip/arch.h"
47
#include "lwip/inet.h"
51
/* These are some reference implementations of the checksum algorithm, with the
52
* aim of being simple, correct and fully portable. Checksumming is the
53
* first thing you would want to optimize for your platform. If you create
54
* your own version, link it in and in your sys_arch.h put:
56
* #define LWIP_CHKSUM <your_checksum_routine>
59
#define LWIP_CHKSUM lwip_standard_chksum
65
* @param dataptr points to start of data to be summed at any boundary
66
* @param len length of data to be summed
67
* @return host order (!) lwip checksum (non-inverted Internet sum)
69
* @note accumulator size limits summable length to 64k
70
* @note host endianess is irrelevant (p3 RFC1071)
73
lwip_standard_chksum(void *dataptr, u16_t len)
80
/* dataptr may be at odd or even addresses */
81
octetptr = (u8_t*)dataptr;
84
/* declare first octet as most significant
85
thus assume network order, ignoring host order */
86
src = (*octetptr) << 8;
88
/* declare second octet as least significant */
96
/* accumulate remaining octet */
97
src = (*octetptr) << 8;
100
/* add deferred carry bits */
101
acc = (acc >> 16) + (acc & 0x0000ffffUL);
102
if ((acc & 0xffff0000) != 0) {
103
acc = (acc >> 16) + (acc & 0x0000ffffUL);
105
/* This maybe a little confusing: reorder sum using htons()
106
instead of ntohs() since it has a little less call overhead.
107
The caller must invert bits for Internet sum ! */
108
return htons((u16_t)acc);
112
#if 0 /* Version B */
118
* IP checksum two bytes at a time with support for
120
* Works for len up to and including 0x20000.
121
* by Curt McDowell, Broadcom Corp. 12/08/2005
123
* @param dataptr points to start of data to be summed at any boundary
124
* @param len length of data to be summed
125
* @return host order (!) lwip checksum (non-inverted Internet sum)
129
lwip_standard_chksum(void *dataptr, int len)
134
int odd = ((u32_t)pb & 1);
136
/* Get aligned to u16_t */
137
if (odd && len > 0) {
138
((u8_t *)&t)[1] = *pb++;
142
/* Add the bulk of the data */
149
/* Consume left-over byte, if any */
151
((u8_t *)&t)[0] = *(u8_t *)ps;;
156
/* Fold 32-bit sum to 16 bits */
158
sum = (sum & 0xffff) + (sum >> 16);
160
/* Swap if alignment was odd */
162
sum = ((sum & 0xff) << 8) | ((sum & 0xff00) >> 8);
168
#if 0 /* Version C */
170
* An optimized checksum routine. Basically, it uses loop-unrolling on
171
* the checksum loop, treating the head and tail bytes specially, whereas
172
* the inner loop acts on 8 bytes at a time.
174
* @arg start of buffer to be checksummed. May be an odd byte address.
175
* @len number of bytes in the buffer to be checksummed.
176
* @return host order (!) lwip checksum (non-inverted Internet sum)
178
* by Curt McDowell, Broadcom Corp. December 8th, 2005
182
lwip_standard_chksum(void *dataptr, int len)
188
/* starts at odd byte address? */
189
int odd = ((u32_t)pb & 1);
191
if (odd && len > 0) {
192
((u8_t *)&t)[1] = *pb++;
198
if (((u32_t)ps & 3) && len > 1) {
206
tmp = sum + *pl++; /* ping */
208
tmp++; /* add back carry */
210
sum = tmp + *pl++; /* pong */
212
sum++; /* add back carry */
217
/* make room in upper bits */
218
sum = (sum >> 16) + (sum & 0xffff);
222
/* 16-bit aligned word remaining? */
228
/* dangling tail byte remaining? */
229
if (len > 0) /* include odd byte */
230
((u8_t *)&t)[0] = *(u8_t *)ps;
232
sum += t; /* add end bytes */
234
while (sum >> 16) /* combine halves */
235
sum = (sum >> 16) + (sum & 0xffff);
238
sum = ((sum & 0xff) << 8) | ((sum & 0xff00) >> 8);
244
#endif /* LWIP_CHKSUM */
246
/* inet_chksum_pseudo:
248
* Calculates the pseudo Internet checksum used by TCP and UDP for a pbuf chain.
249
* IP addresses are expected to be in network byte order.
251
* @param p chain of pbufs over that a checksum should be calculated (ip data part)
252
* @param src source ip address (used for checksum of pseudo header)
253
* @param dst destination ip address (used for checksum of pseudo header)
254
* @param proto ip protocol (used for checksum of pseudo header)
255
* @param proto_len length of the ip data part (used for checksum of pseudo header)
256
* @return checksum (as u16_t) to be saved directly in the protocol header
259
inet_chksum_pseudo(struct pbuf *p,
260
struct ip_addr *src, struct ip_addr *dest,
261
u8_t proto, u16_t proto_len)
269
/* iterate through all pbuf in chain */
270
for(q = p; q != NULL; q = q->next) {
271
LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): checksumming pbuf %p (has next %p) \n",
272
(void *)q, (void *)q->next));
273
acc += LWIP_CHKSUM(q->payload, q->len);
274
/*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc));*/
276
acc = (acc & 0xffffUL) + (acc >> 16);
278
if (q->len % 2 != 0) {
279
swapped = 1 - swapped;
280
acc = ((acc & 0xff) << 8) | ((acc & 0xff00UL) >> 8);
282
/*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc));*/
286
acc = ((acc & 0xff) << 8) | ((acc & 0xff00UL) >> 8);
288
acc += (src->addr & 0xffffUL);
289
acc += ((src->addr >> 16) & 0xffffUL);
290
acc += (dest->addr & 0xffffUL);
291
acc += ((dest->addr >> 16) & 0xffffUL);
292
acc += (u32_t)htons((u16_t)proto);
293
acc += (u32_t)htons(proto_len);
296
acc = (acc & 0xffffUL) + (acc >> 16);
298
LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%"X32_F"\n", acc));
299
return (u16_t)~(acc & 0xffffUL);
304
* Calculates the Internet checksum over a portion of memory. Used primarily for IP
307
* @param dataptr start of the buffer to calculate the checksum (no alignment needed)
308
* @param len length of the buffer to calculate the checksum
309
* @return checksum (as u16_t) to be saved directly in the protocol header
313
inet_chksum(void *dataptr, u16_t len)
317
acc = LWIP_CHKSUM(dataptr, len);
319
acc = (acc & 0xffff) + (acc >> 16);
321
return (u16_t)~(acc & 0xffff);
325
* Calculate a checksum over a chain of pbufs (without pseudo-header, much like
326
* inet_chksum only pbufs are used).
328
* @param p pbuf chain over that the checksum should be calculated
329
* @return checksum (as u16_t) to be saved directly in the protocol header
332
inet_chksum_pbuf(struct pbuf *p)
340
for(q = p; q != NULL; q = q->next) {
341
acc += LWIP_CHKSUM(q->payload, q->len);
343
acc = (acc & 0xffffUL) + (acc >> 16);
345
if (q->len % 2 != 0) {
346
swapped = 1 - swapped;
347
acc = (acc & 0x00ffUL << 8) | (acc & 0xff00UL >> 8);
352
acc = ((acc & 0x00ffUL) << 8) | ((acc & 0xff00UL) >> 8);
354
return (u16_t)~(acc & 0xffffUL);
357
/* Here for now until needed in other places in lwIP */
359
#define in_range(c, lo, up) ((u8_t)c >= lo && (u8_t)c <= up)
360
#define isprint(c) in_range(c, 0x20, 0x7f)
361
#define isdigit(c) in_range(c, '0', '9')
362
#define isxdigit(c) (isdigit(c) || in_range(c, 'a', 'f') || in_range(c, 'A', 'F'))
363
#define islower(c) in_range(c, 'a', 'z')
364
#define isspace(c) (c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v')
368
* Ascii internet address interpretation routine.
369
* The value returned is in network order.
371
* @param cp IP address in ascii represenation (e.g. "127.0.0.1")
372
* @return ip address in network order
375
inet_addr(const char *cp)
379
if (inet_aton(cp, &val)) {
382
return (INADDR_NONE);
386
* Check whether "cp" is a valid ascii representation
387
* of an Internet address and convert to a binary address.
388
* Returns 1 if the address is valid, 0 if not.
389
* This replaces inet_addr, the return value from which
390
* cannot distinguish between failure and a local broadcast address.
392
* @param cp IP address in ascii represenation (e.g. "127.0.0.1")
393
* @param addr pointer to which to save the ip address in network order
394
* @return 1 if cp could be converted to addr, 0 on failure
397
inet_aton(const char *cp, struct in_addr *addr)
407
* Collect number up to ``.''.
408
* Values are specified as for C:
409
* 0x=hex, 0=octal, 1-9=decimal.
417
if (c == 'x' || c == 'X') {
425
val = (val * base) + (int)(c - '0');
427
} else if (base == 16 && isxdigit(c)) {
428
val = (val << 4) | (int)(c + 10 - (islower(c) ? 'a' : 'A'));
437
* a.b.c (with c treated as 16 bits)
438
* a.b (with b treated as 24 bits)
448
* Check for trailing characters.
450
if (c != '\0' && (!isprint(c) || !isspace(c)))
453
* Concoct the address according to
454
* the number of parts specified.
460
return (0); /* initial nondigit */
462
case 1: /* a -- 32 bits */
465
case 2: /* a.b -- 8.24 bits */
466
if (val > 0xffffffUL)
468
val |= parts[0] << 24;
471
case 3: /* a.b.c -- 8.8.16 bits */
474
val |= (parts[0] << 24) | (parts[1] << 16);
477
case 4: /* a.b.c.d -- 8.8.8.8 bits */
480
val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
484
addr->s_addr = htonl(val);
489
* Convert numeric IP address into decimal dotted ASCII representation.
490
* returns ptr to static buffer; not reentrant!
492
* @paran addr ip address in network order to convert
493
* @return pointer to a global static (!) buffer that holds the ASCII
494
* represenation of addr
497
inet_ntoa(struct in_addr addr)
500
u32_t s_addr = addr.s_addr;
509
ap = (u8_t *)&s_addr;
510
for(n = 0; n < 4; n++) {
513
rem = *ap % (u8_t)10;
515
inv[i++] = '0' + rem;
527
* These are reference implementations of the byte swapping functions.
528
* Again with the aim of being simple, correct and fully portable.
529
* Byte swapping is the second thing you would want to optimize. You will
530
* need to port it to your architecture and in your cc.h:
532
* #define LWIP_PLATFORM_BYTESWAP 1
533
* #define LWIP_PLATFORM_HTONS(x) <your_htons>
534
* #define LWIP_PLATFORM_HTONL(x) <your_htonl>
536
* Note ntohs() and ntohl() are merely references to the htonx counterparts.
540
#error BYTE_ORDER is not defined
542
#if (LWIP_PLATFORM_BYTESWAP == 0) && (BYTE_ORDER == LITTLE_ENDIAN)
545
* Convert an u16_t from host- to network byte order.
547
* @param n u16_t in host byte order
548
* @return n in network byte order
553
return ((n & 0xff) << 8) | ((n & 0xff00) >> 8);
557
* Convert an u16_t from network- to host byte order.
559
* @param n u16_t in network byte order
560
* @return n in host byte order
569
* Convert an u32_t from host- to network byte order.
571
* @param n u32_t in host byte order
572
* @return n in network byte order
577
return ((n & 0xff) << 24) |
578
((n & 0xff00) << 8) |
579
((n & 0xff0000UL) >> 8) |
580
((n & 0xff000000UL) >> 24);
584
* Convert an u32_t from network- to host byte order.
586
* @param n u32_t in network byte order
587
* @return n in host byte order
595
#endif /* (LWIP_PLATFORM_BYTESWAP == 0) && (BYTE_ORDER == LITTLE_ENDIAN) */
added
removed
src/lwip/src/core/inet.c
