From a97e1cc4d1195f56bc10acbcd469bb71e016476c Mon Sep 17 00:00:00 2001 From: patacongo Date: Wed, 7 Nov 2007 18:54:35 +0000 Subject: Finished partitioning uip.c (now system is broken) git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@375 42af7a65-404d-4744-a932-0658087f49c3 --- nuttx/fs/fs_open.c | 2 + nuttx/include/net/uip/uip-arch.h | 58 +- nuttx/include/net/uip/uip.h | 190 ++-- nuttx/net/uip/Make.defs | 23 +- nuttx/net/uip/uip-chksum.c | 49 +- nuttx/net/uip/uip-icmpinput.c | 243 ++++++ nuttx/net/uip/uip-initialize.c | 45 + nuttx/net/uip/uip-input.c | 509 +++++++++++ nuttx/net/uip/uip-internal.h | 72 +- nuttx/net/uip/uip-poll.c | 10 +- nuttx/net/uip/uip-setipid.c | 78 ++ nuttx/net/uip/uip-split.c | 8 +- nuttx/net/uip/uip-tcpappsend.c | 225 +++++ nuttx/net/uip/uip-tcpcallback.c | 105 +++ nuttx/net/uip/uip-tcpinput.c | 753 ++++++++++++++++ nuttx/net/uip/uip-tcppoll.c | 126 +++ nuttx/net/uip/uip-tcpsend.c | 365 ++++++++ nuttx/net/uip/uip-tcptimer.c | 241 ++++++ nuttx/net/uip/uip-udpsend.c | 5 +- nuttx/net/uip/uip.c | 1767 -------------------------------------- 20 files changed, 2944 insertions(+), 1930 deletions(-) create mode 100644 nuttx/net/uip/uip-icmpinput.c create mode 100644 nuttx/net/uip/uip-input.c create mode 100644 nuttx/net/uip/uip-setipid.c create mode 100644 nuttx/net/uip/uip-tcpappsend.c create mode 100644 nuttx/net/uip/uip-tcpcallback.c create mode 100644 nuttx/net/uip/uip-tcpinput.c create mode 100644 nuttx/net/uip/uip-tcppoll.c create mode 100644 nuttx/net/uip/uip-tcpsend.c create mode 100644 nuttx/net/uip/uip-tcptimer.c delete mode 100644 nuttx/net/uip/uip.c (limited to 'nuttx') diff --git a/nuttx/fs/fs_open.c b/nuttx/fs/fs_open.c index 094710d31..71fc8d0c4 100644 --- a/nuttx/fs/fs_open.c +++ b/nuttx/fs/fs_open.c @@ -74,7 +74,9 @@ int open(const char *path, int oflags, ...) struct filelist *list; FAR struct inode *inode; const char *relpath = NULL; +#ifdef CONFIG_FILE_MODE mode_t mode = 0666; +#endif int ret; int fd; diff --git a/nuttx/include/net/uip/uip-arch.h b/nuttx/include/net/uip/uip-arch.h index 8f1d6b41f..1d4337839 100644 --- a/nuttx/include/net/uip/uip-arch.h +++ b/nuttx/include/net/uip/uip-arch.h @@ -57,28 +57,20 @@ * Definitions ****************************************************************************/ -/* The following flags are passed as an argument to the uip_interrupt() +/* The following flags are passed as an argument to the uip_poll() * function. They are used to distinguish between the two cases where - * uip_interrupt() is called. It can be called either because we have + * uip_poll() is called. It can be called either because we have * incoming data that should be processed, or because the periodic - * timer has fired. These values are never used directly, but only in - * the macrose defined in this file. + * timer has fired. * - * UIP_DRV_RECEIVE - There is new incoming data from the driver in the d_buf - * field of the uip_driver_s structure. The length of the - * new data is provided in the d_len field of the - * uip_driver_s structure. * UIP_DRV_TIMER - Called periodically from driver to service timeout- * related activities to and to get timeout-related * responses (e.g., reset) * UIP_DRV_POLL - Poll TCP for data to be transmitted - * UIP_DRV_UDPPOLL - Poll for UDP data to be transmitted. This value is used - * internally by the uip_poll logic. */ -#define UIP_DRV_RECEIVE 1 -#define UIP_DRV_TIMER 2 -#define UIP_DRV_POLL 3 +#define UIP_DRV_TIMER 1 +#define UIP_DRV_POLL 2 /**************************************************************************** * Public Types @@ -214,7 +206,7 @@ struct uip_driver_s * * dev->d_len = devicedriver_poll(); * if(dev->d_len > 0) { - * uip_input(); + * uip_input(dev); * if(dev->d_len > 0) { * devicedriver_send(); * } @@ -230,7 +222,7 @@ struct uip_driver_s * if(dev->d_len > 0) { * if(BUF->type == HTONS(UIP_ETHTYPE_IP)) { * uip_arp_ipin(); - * uip_input(); + * uip_input(dev); * if(dev->d_len > 0) { * uip_arp_out(); * devicedriver_send(); @@ -243,12 +235,12 @@ struct uip_driver_s * } */ -#define uip_input(dev) uip_interrupt(dev, UIP_DRV_RECEIVE) +extern void uip_input(struct uip_driver_s *dev); /* Polling of connections. * * This function will traverse each active uIP connection structure and - * perform uip_interrupt with the specified event. After each polling each + * perform uip_input with the specified event. After each polling each * active uIP connection structure, this function will call the provided * callback function if the poll resulted in new data to be send. The poll * will continue until all connections have been polled or until the user- @@ -305,37 +297,29 @@ extern int uip_poll(struct uip_driver_s *dev, uip_poll_callback_t callback, int #define uip_periodic(dev,cb) uip_poll(dev, db, UIP_DRV_TIMER); -/* Architecure support - * - * The actual uIP function which does all the work. Called from the - * interrupt level by a device driver. - */ - -extern void uip_interrupt(struct uip_driver_s *dev, uint8 event); - /* By defining UIP_ARCH_CHKSUM, the architecture can replace the following * functions with hardware assisted solutions. */ /* Carry out a 32-bit addition. * - * Because not all architectures for which uIP is intended has native - * 32-bit arithmetic, uIP uses an external C function for doing the - * required 32-bit additions in the TCP protocol processing. This - * function should add the two arguments and place the result in the - * global variable uip_acc32. + * op32 - A pointer to a 4-byte array representing a 32-bit + * integer in network byte order (big endian). This value may not + * be word aligned. * - * Note: The 32-bit integer pointed to by the op32 parameter and the - * result in the uip_acc32 variable are in network byte order (big - * endian). + * For uip_incr32, the value pointed to by op32 is modified in place + * For uip_add32, the value pointed to by op32 is unmodified +* + * op16 - A 16-bit integer in host byte order. * - * op32 A pointer to a 4-byte array representing a 32-bit - * integer in network byte order (big endian). + * sum - The location to return the result (32-bit, network byte order, + * possibly unaligned). * - * op16 A 16-bit integer in host byte order. + * uip_add32 only. */ -extern void uip_add32(uint8 *op32, uint16 op16); +extern void uip_add32(const uint8 *op32, uint16 op16, uint8 *sum); +extern void uip_incr32(uint8 *op32, uint16 op16); /* Calculate the Internet checksum over a buffer. * diff --git a/nuttx/include/net/uip/uip.h b/nuttx/include/net/uip/uip.h index 283891edb..ed8d85bed 100644 --- a/nuttx/include/net/uip/uip.h +++ b/nuttx/include/net/uip/uip.h @@ -222,55 +222,54 @@ struct uip_stats { struct { - uip_stats_t drop; /* Number of dropped packets at the IP layer. */ - uip_stats_t recv; /* Number of received packets at the IP layer. */ - uip_stats_t sent; /* Number of sent packets at the IP layer. */ - uip_stats_t vhlerr; /* Number of packets dropped due to wrong - IP version or header length. */ - uip_stats_t hblenerr; /* Number of packets dropped due to wrong - IP length, high byte. */ - uip_stats_t lblenerr; /* Number of packets dropped due to wrong - IP length, low byte. */ - uip_stats_t fragerr; /* Number of packets dropped since they - were IP fragments. */ - uip_stats_t chkerr; /* Number of packets dropped due to IP - checksum errors. */ - uip_stats_t protoerr; /* Number of packets dropped since they - were neither ICMP, UDP nor TCP. */ - } ip; /* IP statistics. */ + uip_stats_t drop; /* Number of dropped packets at the IP layer. */ + uip_stats_t recv; /* Number of received packets at the IP layer. */ + uip_stats_t sent; /* Number of sent packets at the IP layer. */ + uip_stats_t vhlerr; /* Number of packets dropped due to wrong + IP version or header length. */ + uip_stats_t hblenerr; /* Number of packets dropped due to wrong + IP length, high byte. */ + uip_stats_t lblenerr; /* Number of packets dropped due to wrong + IP length, low byte. */ + uip_stats_t fragerr; /* Number of packets dropped since they + were IP fragments. */ + uip_stats_t chkerr; /* Number of packets dropped due to IP + checksum errors. */ + uip_stats_t protoerr; /* Number of packets dropped since they + were neither ICMP, UDP nor TCP. */ + } ip; /* IP statistics. */ struct { - uip_stats_t drop; /* Number of dropped ICMP packets. */ - uip_stats_t recv; /* Number of received ICMP packets. */ - uip_stats_t sent; /* Number of sent ICMP packets. */ - uip_stats_t typeerr; /* Number of ICMP packets with a wrong type. */ - } icmp; /* ICMP statistics. */ + uip_stats_t drop; /* Number of dropped ICMP packets. */ + uip_stats_t recv; /* Number of received ICMP packets. */ + uip_stats_t sent; /* Number of sent ICMP packets. */ + uip_stats_t typeerr; /* Number of ICMP packets with a wrong type. */ + } icmp; /* ICMP statistics. */ struct { - uip_stats_t drop; /* Number of dropped TCP segments. */ - uip_stats_t recv; /* Number of recived TCP segments. */ - uip_stats_t sent; /* Number of sent TCP segments. */ - uip_stats_t chkerr; /* Number of TCP segments with a bad checksum. */ - uip_stats_t ackerr; /* Number of TCP segments with a bad ACK number. */ - uip_stats_t rst; /* Number of recevied TCP RST (reset) segments. */ - uip_stats_t rexmit; /* Number of retransmitted TCP segments. */ - uip_stats_t syndrop; /* Number of dropped SYNs due to too few - connections was avaliable. */ - uip_stats_t synrst; /* Number of SYNs for closed ports, - triggering a RST. */ - } tcp; /* TCP statistics. */ + uip_stats_t drop; /* Number of dropped TCP segments. */ + uip_stats_t recv; /* Number of recived TCP segments. */ + uip_stats_t sent; /* Number of sent TCP segments. */ + uip_stats_t chkerr; /* Number of TCP segments with a bad checksum. */ + uip_stats_t ackerr; /* Number of TCP segments with a bad ACK number. */ + uip_stats_t rst; /* Number of recevied TCP RST (reset) segments. */ + uip_stats_t rexmit; /* Number of retransmitted TCP segments. */ + uip_stats_t syndrop; /* Number of dropped SYNs due to too few + connections was avaliable. */ + uip_stats_t synrst; /* Number of SYNs for closed ports, triggering a RST. */ + } tcp; /* TCP statistics. */ #ifdef CONFIG_NET_UDP struct { - uip_stats_t drop; /* Number of dropped UDP segments. */ - uip_stats_t recv; /* Number of recived UDP segments. */ - uip_stats_t sent; /* Number of sent UDP segments. */ - uip_stats_t chkerr; /* Number of UDP segments with a bad checksum. */ - } udp; /* UDP statistics. */ + uip_stats_t drop; /* Number of dropped UDP segments. */ + uip_stats_t recv; /* Number of recived UDP segments. */ + uip_stats_t sent; /* Number of sent UDP segments. */ + uip_stats_t chkerr; /* Number of UDP segments with a bad checksum. */ + } udp; /* UDP statistics. */ #endif /* CONFIG_NET_UDP */ }; @@ -282,28 +281,29 @@ struct uip_tcpip_hdr /* IPv6 Ip header. */ - uint8 vtc; - uint8 tcflow; - uint16 flow; - uint8 len[2]; - uint8 proto, ttl; - uip_ip6addr_t srcipaddr; - uip_ip6addr_t destipaddr; + uint8 vtc; /* Bits 0-3: version, bits 4-7: traffic class (MS) */ + uint8 tcf; /* Bits 0-3: traffic class (LS), 4-bits: flow label (MS) */ + uint16 flow; /* 16-bit flow label (LS) */ + uint8 len[2]; /* 16-bit Payload length */ + uint8 proto; /* 8-bit Next header (same as IPv4 protocol field) */ + uint8 ttl; /* 8-bit Hop limit (like IPv4 TTL field) */ + uip_ip6addr_t srcipaddr; /* 128-bit Source address */ + uip_ip6addr_t destipaddr; /* 128-bit Destination address */ #else /* CONFIG_NET_IPv6 */ /* IPv4 IP header. */ - uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */ - uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */ - uint8 len[2]; /* 16-bit Total length */ - uint8 ipid[2]; /* 16-bit Identification */ - uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */ - uint8 ttl; /* 8-bit Time to Live */ - uint8 proto; /* 8-bit Protocol */ - uint16 ipchksum; /* 16-bit Header checksum */ - uint16 srcipaddr[2]; /* 32-bit Source IP address */ - uint16 destipaddr[2]; /* 32-bit Destination IP address */ + uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */ + uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */ + uint8 len[2]; /* 16-bit Total length */ + uint8 ipid[2]; /* 16-bit Identification */ + uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */ + uint8 ttl; /* 8-bit Time to Live */ + uint8 proto; /* 8-bit Protocol */ + uint16 ipchksum; /* 16-bit Header checksum */ + uint16 srcipaddr[2]; /* 32-bit Source IP address */ + uint16 destipaddr[2]; /* 32-bit Destination IP address */ #endif /* CONFIG_NET_IPv6 */ @@ -327,31 +327,31 @@ struct uip_icmpip_hdr { #ifdef CONFIG_NET_IPv6 - /* IPv6 IP header. */ + /* IPv6 Ip header. */ - uint8 vtc; - uint8 tcf; - uint16 flow; - uint8 len[2]; - uint8 proto; - uint8 ttl; - uip_ip6addr_t srcipaddr; - uip_ip6addr_t destipaddr; + uint8 vtc; /* Bits 0-3: version, bits 4-7: traffic class (MS) */ + uint8 tcf; /* Bits 0-3: traffic class (LS), bits 4-7: flow label (MS) */ + uint16 flow; /* 16-bit flow label (LS) */ + uint8 len[2]; /* 16-bit Payload length */ + uint8 proto; /* 8-bit Next header (same as IPv4 protocol field) */ + uint8 ttl; /* 8-bit Hop limit (like IPv4 TTL field) */ + uip_ip6addr_t srcipaddr; /* 128-bit Source address */ + uip_ip6addr_t destipaddr; /* 128-bit Destination address */ #else /* CONFIG_NET_IPv6 */ /* IPv4 IP header. */ - uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */ - uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */ - uint8 len[2]; /* 16-bit Total length */ - uint8 ipid[2]; /* 16-bit Identification */ - uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */ - uint8 ttl; /* 8-bit Time to Live */ - uint8 proto; /* 8-bit Protocol */ - uint16 ipchksum; /* 16-bit Header checksum */ - uint16 srcipaddr[2]; /* 32-bit Source IP address */ - uint16 destipaddr[2]; /* 32-bit Destination IP address */ + uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */ + uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */ + uint8 len[2]; /* 16-bit Total length */ + uint8 ipid[2]; /* 16-bit Identification */ + uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */ + uint8 ttl; /* 8-bit Time to Live */ + uint8 proto; /* 8-bit Protocol */ + uint16 ipchksum; /* 16-bit Header checksum */ + uint16 srcipaddr[2]; /* 32-bit Source IP address */ + uint16 destipaddr[2]; /* 32-bit Destination IP address */ #endif /* CONFIG_NET_IPv6 */ @@ -384,31 +384,31 @@ struct uip_udpip_hdr { #ifdef CONFIG_NET_IPv6 - /* IPv6 IP header. */ + /* IPv6 Ip header. */ - uint8 vtc; - uint8 tcf; - uint16 flow; - uint8 len[2]; - uint8 proto; - uint8 ttl; - uip_ip6addr_t srcipaddr; - uip_ip6addr_t destipaddr; + uint8 vtc; /* Bits 0-3: version, bits 4-7: traffic class (MS) */ + uint8 tcf; /* Bits 0-3: traffic class (LS), 4-bits: flow label (MS) */ + uint16 flow; /* 16-bit flow label (LS) */ + uint8 len[2]; /* 16-bit Payload length */ + uint8 proto; /* 8-bit Next header (same as IPv4 protocol field) */ + uint8 ttl; /* 8-bit Hop limit (like IPv4 TTL field) */ + uip_ip6addr_t srcipaddr; /* 128-bit Source address */ + uip_ip6addr_t destipaddr; /* 128-bit Destination address */ #else /* CONFIG_NET_IPv6 */ /* IPv4 header. */ - uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */ - uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */ - uint8 len[2]; /* 16-bit Total length */ - uint8 ipid[2]; /* 16-bit Identification */ - uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */ - uint8 ttl; /* 8-bit Time to Live */ - uint8 proto; /* 8-bit Protocol */ - uint16 ipchksum; /* 16-bit Header checksum */ - uint16 srcipaddr[2]; /* 32-bit Source IP address */ - uint16 destipaddr[2]; /* 32-bit Destination IP address */ + uint8 vhl; /* 8-bit Version (4) and header length (5 or 6) */ + uint8 tos; /* 8-bit Type of service (e.g., 6=TCP) */ + uint8 len[2]; /* 16-bit Total length */ + uint8 ipid[2]; /* 16-bit Identification */ + uint8 ipoffset[2]; /* 16-bit IP flags + fragment offset */ + uint8 ttl; /* 8-bit Time to Live */ + uint8 proto; /* 8-bit Protocol */ + uint16 ipchksum; /* 16-bit Header checksum */ + uint16 srcipaddr[2]; /* 32-bit Source IP address */ + uint16 destipaddr[2]; /* 32-bit Destination IP address */ #endif /* CONFIG_NET_IPv6 */ @@ -459,10 +459,6 @@ extern uint16 uip_urglen; /* Length of (received) urgent data */ extern struct uip_conn *uip_conn; -/* 4-byte array used for the 32-bit sequence number calculations.*/ - -extern uint8 uip_acc32[4]; - /* The current UDP connection. */ #ifdef CONFIG_NET_UDP diff --git a/nuttx/net/uip/Make.defs b/nuttx/net/uip/Make.defs index d150e24fe..8a232ffbf 100644 --- a/nuttx/net/uip/Make.defs +++ b/nuttx/net/uip/Make.defs @@ -38,9 +38,21 @@ UIP_CSRCS = ifeq ($(CONFIG_NET),y) -UIP_CSRCS += uip-initialize.c uip-arp.c uip.c uip-send.c uip-fw.c \ - uip-neighbor.c uip-split.c uip-tcpconn.c uip-listen.c \ - uip-poll.c uip-chksum.c +# Common network source files + +UIP_CSRCS += uip-initialize.c uip-setipid.c uip-arp.c uip-input.c uip-send.c \ + uip-fw.c uip-split.c uip-poll.c uip-chksum.c + +ifeq ($(CONFIG_NET_IPv6),y) +UIP_CSRCS += uip-neighbor.c +endif + +# TCP source files + +UIP_CSRCS += uip-tcpconn.c uip-tcppoll.c uip-tcptimer.c uip-tcpsend.c \ + uip-tcpinput.c uip-tcpappsend.c uip-listen.c uip-tcpcallback.c + +# UDP source files ifeq ($(CONFIG_NET_UDP),y) @@ -48,6 +60,11 @@ UIP_CSRCS += uip-udpconn.c uip-udppoll.c uip-udpsend.c uip-udpinput.c \ uip-udpcallback.c endif + +#ICMP source files + +UIP_CSRCS += uip-icmpinput.c + endif diff --git a/nuttx/net/uip/uip-chksum.c b/nuttx/net/uip/uip-chksum.c index ebf814e8b..c8c173b95 100644 --- a/nuttx/net/uip/uip-chksum.c +++ b/nuttx/net/uip/uip-chksum.c @@ -116,12 +116,15 @@ static uint16 upper_layer_chksum(struct uip_driver_s *dev, uint8 proto) /* First sum pseudoheader. */ /* IP protocol and length fields. This addition cannot carry. */ + sum = upper_layer_len + proto; /* Sum IP source and destination addresses. */ + sum = chksum(sum, (uint8 *)&BUF->srcipaddr, 2 * sizeof(uip_ipaddr_t)); /* Sum TCP header and data. */ + sum = chksum(sum, &dev->d_buf[UIP_IPH_LEN + UIP_LLH_LEN], upper_layer_len); return (sum == 0) ? 0xffff : htons(sum); @@ -143,35 +146,49 @@ static uint16 uip_icmp6chksum(struct uip_driver_s *dev) /* Calculate the Internet checksum over a buffer. */ #if !UIP_ARCH_ADD32 -void uip_add32(uint8 *op32, uint16 op16) +static void uip_carry32(uint8 *sum, uint16 op16) { - uip_acc32[3] = op32[3] + (op16 & 0xff); - uip_acc32[2] = op32[2] + (op16 >> 8); - uip_acc32[1] = op32[1]; - uip_acc32[0] = op32[0]; - - if (uip_acc32[2] < (op16 >> 8)) + if (sum[2] < (op16 >> 8)) { - ++uip_acc32[1]; - if (uip_acc32[1] == 0) + ++sum[1]; + if (sum[1] == 0) { - ++uip_acc32[0]; + ++sum[0]; } } - if (uip_acc32[3] < (op16 & 0xff)) + if (sum[3] < (op16 & 0xff)) { - ++uip_acc32[2]; - if (uip_acc32[2] == 0) + ++sum[2]; + if (sum[2] == 0) { - ++uip_acc32[1]; - if (uip_acc32[1] == 0) + ++sum[1]; + if (sum[1] == 0) { - ++uip_acc32[0]; + ++sum[0]; } } } } + +void uip_add32(const uint8 *op32, uint16 op16, uint8 *sum) +{ + /* op32 and the sum are in network order (big-endian); op16 is host order. */ + + sum[3] = op32[3] + (op16 & 0xff); + sum[2] = op32[2] + (op16 >> 8); + sum[1] = op32[1]; + sum[0] = op32[0]; + uip_carry32(sum, op16); +} + +void uip_incr32(uint8 *op32, uint16 op16) +{ + op32[3] += (op16 & 0xff); + op32[2] += (op16 >> 8); + uip_carry32(op32, op16); +} + #endif /* UIP_ARCH_ADD32 */ #if !UIP_ARCH_CHKSUM diff --git a/nuttx/net/uip/uip-icmpinput.c b/nuttx/net/uip/uip-icmpinput.c new file mode 100644 index 000000000..c3d30dd4e --- /dev/null +++ b/nuttx/net/uip/uip-icmpinput.c @@ -0,0 +1,243 @@ +/**************************************************************************** + * net/uip/uip-icmpinput.c + * Handling incoming ICMP/ICMP6 input + * + * Copyright (C) 2007 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Adapted for NuttX from logic in uIP which also has a BSD-like license: + * + * Original author Adam Dunkels + * Copyright () 2001-2003, Adam Dunkels. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#ifdef CONFIG_NET + +#include +#include + +#include +#include +#include + +#include "uip-internal.h" + +/**************************************************************************** + * Definitions + ****************************************************************************/ + +#define ICMPBUF ((struct uip_icmpip_hdr *)&dev->d_buf[UIP_LLH_LEN]) + +/**************************************************************************** + * Public Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: uip_icmpinput + * + * Description: + * Handle incoming ICMP/ICMP6 input + * + * Parameters: + * dev - The device driver structure containing the received ICMP/ICMP6 + * packet + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +void uip_icmpinput(struct uip_driver_s *dev) +{ +#ifdef CONFIG_NET_STATISTICS + uip_stat.icmp.recv++; +#endif + +#ifndef CONFIG_NET_IPv6 + /* ICMPv4 processing code follows. */ + + /* ICMP echo (i.e., ping) processing. This is simple, we only change the + * ICMP type from ECHO to ECHO_REPLY and adjust the ICMP checksum before + * we return the packet. + */ + + if (ICMPBUF->type != ICMP_ECHO) + { + uip_log("icmp: not ICMP echo."); + goto typeerr; + } + + /* If we are configured to use ping IP address assignment, we use + * the destination IP address of this ping packet and assign it to + * ourself. + */ + +#if UIP_PINGADDRCONF + if (dev->d_ipaddr == 0) + { + dev->d_ipaddr = ICMPBUF->destipaddr; + } +#endif /* UIP_PINGADDRCONF */ + + ICMPBUF->type = ICMP_ECHO_REPLY; + + if (ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) + { + ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1; + } + else + { + ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8); + } + + /* Swap IP addresses. */ + + uiphdr_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr); + uiphdr_ipaddr_copy(ICMPBUF->srcipaddr, &dev->d_ipaddr); + + vdbg("Outgoing ICMP packet length: %d (%d)\n", + dev->d_len, (ICMPBUF->len[0] << 8) | ICMPBUF->len[1]); + +#ifdef CONFIG_NET_STATISTICS + uip_stat.icmp.sent++; + uip_stat.ip.sent++; +#endif + return; + +typeerr: +#ifdef CONFIG_NET_STATISTICS + uip_stat.icmp.typeerr++; + uip_stat.icmp.drop++; +#endif + dev->d_len = 0; + +#else /* !CONFIG_NET_IPv6 */ + + /* If we get a neighbor solicitation for our address we should send + * a neighbor advertisement message back. + */ + + if (ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION) + { + if (uip_ipaddr_cmp(ICMPBUF->icmp6data, dev->d_ipaddr)) + { + if (ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS) + { + /* Save the sender's address in our neighbor list. */ + + uiphdr_neighbor_add(ICMPBUF->srcipaddr, &(ICMPBUF->options[2])); + } + + /* We should now send a neighbor advertisement back to where the + * neighbor solicication came from. + */ + + ICMPBUF->type = ICMP6_NEIGHBOR_ADVERTISEMENT; + ICMPBUF->flags = ICMP6_FLAG_S; /* Solicited flag. */ + + ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0; + + uiphdr_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr); + uiphdr_ipaddr_copy(ICMPBUF->srcipaddr, dev->d_ipaddr); + ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS; + ICMPBUF->options[1] = 1; /* Options length, 1 = 8 bytes. */ + memcpy(&(ICMPBUF->options[2]), &dev->d_mac, IFHWADDRLEN); + ICMPBUF->icmpchksum = 0; + ICMPBUF->icmpchksum = ~uip_icmp6chksum(dev); + } + else + { + goto drop; + } + } + else if (ICMPBUF->type == ICMP6_ECHO) + { + /* ICMP echo (i.e., ping) processing. This is simple, we only + * change the ICMP type from ECHO to ECHO_REPLY and update the + * ICMP checksum before we return the packet. + */ + + ICMPBUF->type = ICMP6_ECHO_REPLY; + + uiphdr_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr); + uiphdr_ipaddr_copy(ICMPBUF->srcipaddr, dev->d_ipaddr); + ICMPBUF->icmpchksum = 0; + ICMPBUF->icmpchksum = ~uip_icmp6chksum(dev); + } + else + { + uip_log("icmp: unknown ICMP6 message."); + goto typeerr; + } + + vdbg("Outgoing ICMP6 packet length: %d (%d)\n", + dev->d_len, (ICMPBUF->len[0] << 8) | ICMPBUF->len[1]); + +#ifdef CONFIG_NET_STATISTICS + uip_stat.icmp.sent++; + uip_stat.ip.sent++; +#endif + return; + +typeerr: +#ifdef CONFIG_NET_STATISTICS + uip_stat.icmp.typeerr++; +#endif + +drop: +#ifdef CONFIG_NET_STATISTICS + uip_stat.icmp.drop++; +#endif + dev->d_len = 0; + +#endif /* !CONFIG_NET_IPv6 */ +} + +#endif /* CONFIG_NET */ diff --git a/nuttx/net/uip/uip-initialize.c b/nuttx/net/uip/uip-initialize.c index dabcf64cc..00a01ef6a 100644 --- a/nuttx/net/uip/uip-initialize.c +++ b/nuttx/net/uip/uip-initialize.c @@ -57,6 +57,51 @@ * Public Variables ****************************************************************************/ +#if UIP_URGDATA > 0 +void *uip_urgdata; /* urgent data (out-of-band data), if present. */ +uint16 uip_urglen; /* Length of (received) urgent data */ +#endif + +/* The uip_flags variable is used for communication between the TCP/IP + * stack and the application program. + */ + +uint8 uip_flags; + +/* uip_conn always points to the current connection. */ + +struct uip_conn *uip_conn; + +#ifdef CONFIG_NET_UDP +struct uip_udp_conn *uip_udp_conn; +#endif /* CONFIG_NET_UDP */ + +#ifdef CONFIG_NET_STATISTICS +struct uip_stats uip_stat; +#endif + +/* Increasing number used for the IP ID field. */ + +uint16 g_ipid; + +const uip_ipaddr_t all_ones_addr = +#ifdef CONFIG_NET_IPv6 + {0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff}; +#else /* CONFIG_NET_IPv6 */ + {0xffffffff}; +#endif /* CONFIG_NET_IPv6 */ + +const uip_ipaddr_t all_zeroes_addr = +#ifdef CONFIG_NET_IPv6 + {0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000}; +#else + {0x00000000}; +#endif + +#if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6) +uint8 uip_reasstmr; +#endif + /**************************************************************************** * Private Variables ****************************************************************************/ diff --git a/nuttx/net/uip/uip-input.c b/nuttx/net/uip/uip-input.c new file mode 100644 index 000000000..de8223640 --- /dev/null +++ b/nuttx/net/uip/uip-input.c @@ -0,0 +1,509 @@ +/**************************************************************************** + * net/uip/uip-input.c + * The uIP TCP/IP stack code. + * + * Copyright (C) 2007 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Adapted for NuttX from logic in uIP which also has a BSD-like license: + * + * uIP is an implementation of the TCP/IP protocol stack intended for + * small 8-bit and 16-bit microcontrollers. + * + * uIP provides the necessary protocols for Internet communication, + * with a very small code footprint and RAM requirements - the uIP + * code size is on the order of a few kilobytes and RAM usage is on + * the order of a few hundred bytes. + * + * Original author Adam Dunkels + * Copyright () 2001-2003, Adam Dunkels. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * uIP is a small implementation of the IP, UDP and TCP protocols (as + * well as some basic ICMP stuff). The implementation couples the IP, + * UDP, TCP and the application layers very tightly. To keep the size + * of the compiled code down, this code frequently uses the goto + * statement. While it would be possible to break the uip_input() + * function into many smaller functions, this would increase the code + * size because of the overhead of parameter passing and the fact that + * the optimier would not be as efficient. + * + * The principle is that we have a small buffer, called the d_buf, + * in which the device driver puts an incoming packet. The TCP/IP + * stack parses the headers in the packet, and calls the + * application. If the remote host has sent data to the application, + * this data is present in the d_buf and the application read the + * data from there. It is up to the application to put this data into + * a byte stream if needed. The application will not be fed with data + * that is out of sequence. + * + * If the application whishes to send data to the peer, it should put + * its data into the d_buf. The d_appdata pointer points to the + * first available byte. The TCP/IP stack will calculate the + * checksums, and fill in the necessary header fields and finally send + * the packet back to the peer. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#ifdef CONFIG_NET + +#include +#include + +#include +#include + +#include +#include +#include + +#ifdef CONFIG_NET_IPv6 +# include "uip-neighbor.h" +#endif /* CONFIG_NET_IPv6 */ + +#include "uip-internal.h" + +/**************************************************************************** + * Definitions + ****************************************************************************/ + +/* Macros. */ + +#define BUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN]) +#define FBUF ((struct uip_tcpip_hdr *)&uip_reassbuf[0]) + +/* IP fragment re-assembly */ + +#define IP_MF 0x20 +#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN) +#define UIP_REASS_FLAG_LASTFRAG 0x01 + +/**************************************************************************** + * Public Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Variables + ****************************************************************************/ + +#if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6) +static uint8 uip_reassbuf[UIP_REASS_BUFSIZE]; +static uint8 uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)]; +static const uint8 bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01}; +static uint16 uip_reasslen; +static uint8 uip_reassflags; +#endif /* UIP_REASSEMBLY */ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Function: uip_reass + * + * Description: + * IP fragment reassembly: not well-tested. + * + * Assumptions: + * + ****************************************************************************/ + +#if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6) +static uint8 uip_reass(void) +{ + uint16 offset, len; + uint16 i; + + /* If ip_reasstmr is zero, no packet is present in the buffer, so we + * write the IP header of the fragment into the reassembly + * buffer. The timer is updated with the maximum age. + */ + + if (uip_reasstmr == 0) + { + memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN); + uip_reasstmr = UIP_REASS_MAXAGE; + uip_reassflags = 0; + + /* Clear the bitmap. */ + memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap)); + } + + /* Check if the incoming fragment matches the one currently present + * in the reasembly buffer. If so, we proceed with copying the + * fragment into the buffer. + */ + + if (uiphdr_addr_cmp(BUF->srcipaddr, FBUF->srcipaddr) && + uiphdr_addr_cmp(BUF->destipaddr == FBUF->destipaddr) && + BUF->g_ipid[0] == FBUF->g_ipid[0] && BUF->g_ipid[1] == FBUF->g_ipid[1]) + { + len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4; + offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8; + + /* If the offset or the offset + fragment length overflows the + * reassembly buffer, we discard the entire packet. + */ + + if (offset > UIP_REASS_BUFSIZE || offset + len > UIP_REASS_BUFSIZE) + { + uip_reasstmr = 0; + goto nullreturn; + } + + /* Copy the fragment into the reassembly buffer, at the right offset. */ + + memcpy(&uip_reassbuf[UIP_IPH_LEN + offset], (char *)BUF + (int)((BUF->vhl & 0x0f) * 4), len); + + /* Update the bitmap. */ + + if (offset / (8 * 8) == (offset + len) / (8 * 8)) + { + /* If the two endpoints are in the same byte, we only update that byte. */ + + uip_reassbitmap[offset / (8 * 8)] |= + bitmap_bits[(offset / 8 ) & 7] & ~bitmap_bits[((offset + len) / 8 ) & 7]; + + } + else + { + /* If the two endpoints are in different bytes, we update the bytes + * in the endpoints and fill the stuff inbetween with 0xff. + */ + + uip_reassbitmap[offset / (8 * 8)] |= bitmap_bits[(offset / 8 ) & 7]; + for (i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) + { + uip_reassbitmap[i] = 0xff; + } + uip_reassbitmap[(offset + len) / (8 * 8)] |= ~bitmap_bits[((offset + len) / 8 ) & 7]; + } + + /* If this fragment has the More Fragments flag set to zero, we know that + * this is the last fragment, so we can calculate the size of the entire + * packet. We also set the IP_REASS_FLAG_LASTFRAG flag to indicate that + * we have received the final fragment. + */ + + if ((BUF->ipoffset[0] & IP_MF) == 0) + { + uip_reassflags |= UIP_REASS_FLAG_LASTFRAG; + uip_reasslen = offset + len; + } + + /* Finally, we check if we have a full packet in the buffer. We do this + * by checking if we have the last fragment and if all bits in the bitmap + * are set. + */ + + if (uip_reassflags & UIP_REASS_FLAG_LASTFRAG) + { + /* Check all bytes up to and including all but the last byte in + * the bitmap. + */ + + for (i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) + { + if (uip_reassbitmap[i] != 0xff) + { + goto nullreturn; + } + } + + /* Check the last byte in the bitmap. It should contain just the + * right amount of bits. + */ + + if (uip_reassbitmap[uip_reasslen / (8 * 8)] != (uint8)~bitmap_bits[uip_reasslen / 8 & 7]) + { + goto nullreturn; + } + + /* If we have come this far, we have a full packet in the buffer, + * so we allocate a pbuf and copy the packet into it. We also reset + * the timer. + */ + + uip_reasstmr = 0; + memcpy(BUF, FBUF, uip_reasslen); + + /* Pretend to be a "normal" (i.e., not fragmented) IP packet from + * now on. + */ + + BUF->ipoffset[0] = BUF->ipoffset[1] = 0; + BUF->len[0] = uip_reasslen >> 8; + BUF->len[1] = uip_reasslen & 0xff; + BUF->ipchksum = 0; + BUF->ipchksum = ~(uip_ipchksum(dev)); + + return uip_reasslen; + } + } + +nullreturn: + return 0; +} +#endif /* UIP_REASSEMBLY */ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Function: uip_input + * + * Description: + * + * Assumptions: + * + ****************************************************************************/ + +void uip_input(struct uip_driver_s *dev) +{ + dev->d_snddata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN]; + dev->d_appdata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN]; + + /* This is where the input processing starts. */ + +#ifdef CONFIG_NET_STATISTICS + uip_stat.ip.recv++; +#endif + + /* Start of IP input header processing code. */ + +#ifdef CONFIG_NET_IPv6 + /* Check validity of the IP header. */ + + if ((BUF->vtc & 0xf0) != 0x60) + { + /* IP version and header length. */ + +#ifdef CONFIG_NET_STATISTICS + uip_stat.ip.drop++; + uip_stat.ip.vhlerr++; +#endif + uip_log("ipv6: invalid version."); + goto drop; + } +#else /* CONFIG_NET_IPv6 */ + /* Check validity of the IP header. */ + + if (BUF->vhl != 0x45) + { + /* IP version and header length. */ + +#ifdef CONFIG_NET_STATISTICS + uip_stat.ip.drop++; + uip_stat.ip.vhlerr++; +#endif + uip_log("ip: invalid version or header length."); + goto drop; + } +#endif /* CONFIG_NET_IPv6 */ + + /* Check the size of the packet. If the size reported to us in d_len is + * smaller the size reported in the IP header, we assume that the packet + * has been corrupted in transit. If the size of d_len is larger than the + * size reported in the IP packet header, the packet has been padded and + * we set d_len to the correct value. + */ + + if ((BUF->len[0] << 8) + BUF->len[1] <= dev->d_len) + { + dev->d_len = (BUF->len[0] << 8) + BUF->len[1]; +#ifdef CONFIG_NET_IPv6 + /* The length reported in the IPv6 header is the length of the + * payload that follows the header. However, uIP uses the d_len + * variable for holding the size of the entire packet, including the + * IP header. For IPv4 this is not a problem as the length field in + * the IPv4 header contains the length of the entire packet. But + * for IPv6 we need to add the size of the IPv6 header (40 bytes). + */ + + dev->d_len += 40; +#endif /* CONFIG_NET_IPv6 */ + } + else + { + uip_log("ip: packet shorter than reported in IP header."); + goto drop; + } + +#ifndef CONFIG_NET_IPv6 + /* Check the fragment flag. */ + + if ((BUF->ipoffset[0] & 0x3f) != 0 || BUF->ipoffset[1] != 0) + { +#if UIP_REASSEMBLY + dev->d_len = uip_reass(); + if (dev->d_len == 0) + { + goto drop; + } +#else /* UIP_REASSEMBLY */ +#ifdef CONFIG_NET_STATISTICS + uip_stat.ip.drop++; + uip_stat.ip.fragerr++; +#endif + uip_log("ip: fragment dropped."); + goto drop; +#endif /* UIP_REASSEMBLY */ + } +#endif /* CONFIG_NET_IPv6 */ + + if (uip_ipaddr_cmp(dev->d_ipaddr, all_zeroes_addr)) + { + /* If we are configured to use ping IP address configuration and + * hasn't been assigned an IP address yet, we accept all ICMP + * packets. + */ + +#if UIP_PINGADDRCONF && !CONFIG_NET_IPv6 + if (BUF->proto == UIP_PROTO_ICMP) + { + uip_log("ip: possible ping config packet received."); + uip_icmpinput(dev); + goto done; + } + else +#endif /* UIP_PINGADDRCONF */ + { + uip_log("ip: packet dropped since no address assigned."); + goto drop; + } + } + else + { + /* If IP broadcast support is configured, we check for a broadcast + * UDP packet, which may be destined to us. + */ + +#if UIP_BROADCAST + if (BUF->proto == UIP_PROTO_UDP && uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr) + { + uip_udpinput(dev); + return; + } +#endif /* UIP_BROADCAST */ + + /* Check if the packet is destined for our IP address. */ +#ifndef CONFIG_NET_IPv6 + if (!uip_ipaddr_cmp(uip_ip4addr_conv(BUF->destipaddr), dev->d_ipaddr)) + { +#ifdef CONFIG_NET_STATISTICS + uip_stat.ip.drop++; +#endif + goto drop; + } +#else /* CONFIG_NET_IPv6 */ + /* For IPv6, packet reception is a little trickier as we need to + * make sure that we listen to certain multicast addresses (all + * hosts multicast address, and the solicited-node multicast + * address) as well. However, we will cheat here and accept all + * multicast packets that are sent to the ff02::/16 addresses. + */ + + if (!uip_ipaddr_cmp(BUF->destipaddr, dev->d_ipaddr) && + BUF->destipaddr & HTONL(0xffff0000) != HTONL(0xff020000)) + { +#ifdef CONFIG_NET_STATISTICS + uip_stat.ip.drop++; +#endif + goto drop; + } +#endif /* CONFIG_NET_IPv6 */ + } + +#ifndef CONFIG_NET_IPv6 + if (uip_ipchksum(dev) != 0xffff) + { + /* Compute and check the IP header checksum. */ + +#ifdef CONFIG_NET_STATISTICS + uip_stat.ip.drop++; + uip_stat.ip.chkerr++; +#endif + uip_log("ip: bad checksum."); + goto drop; + } +#endif /* CONFIG_NET_IPv6 */ + + /* Everything looks good so far. Now process the incoming packet + * according to the protocol. + */ + + switch (BUF->proto) + { + case UIP_PROTO_TCP: /* TCP input */ + uip_tcpinput(dev); + break; + +#ifdef CONFIG_NET_UDP + case UIP_PROTO_UDP: /* UDP input */ + uip_udpinput(dev); + break; +#endif + + /* Check for ICMP input */ + +#ifndef CONFIG_NET_IPv6 + case UIP_PROTO_ICMP: /* ICMP input */ +#else + case UIP_PROTO_ICMP6: /* ICMP6 input */ +#endif + uip_icmpinput(dev); + break; + + default: /* Unrecognized/unsupported protocol */ +#ifdef CONFIG_NET_STATISTICS + uip_stat.ip.drop++; + uip_stat.ip.protoerr++; +#endif + + uip_log("ip: Unrecognized IP protocol."); + goto drop; + } + + /* Return and let the caller do any actual transmission. */ + + return; + +drop: + dev->d_len = 0; +} +#endif /* CONFIG_NET */ + diff --git a/nuttx/net/uip/uip-internal.h b/nuttx/net/uip/uip-internal.h index c8d1e10c4..d1f141a30 100644 --- a/nuttx/net/uip/uip-internal.h +++ b/nuttx/net/uip/uip-internal.h @@ -55,6 +55,37 @@ * Public Macro Definitions ****************************************************************************/ +/* TCP definitions */ + +#define TCP_FIN 0x01 +#define TCP_SYN 0x02 +#define TCP_RST 0x04 +#define TCP_PSH 0x08 +#define TCP_ACK 0x10 +#define TCP_URG 0x20 +#define TCP_CTL 0x3f + +#define TCP_OPT_END 0 /* End of TCP options list */ +#define TCP_OPT_NOOP 1 /* "No-operation" TCP option */ +#define TCP_OPT_MSS 2 /* Maximum segment size TCP option */ + +#define TCP_OPT_MSS_LEN 4 /* Length of TCP MSS option. */ + +/* ICMP/ICMP6 definitions */ + +#define ICMP_ECHO_REPLY 0 +#define ICMP_ECHO 8 + +#define ICMP6_ECHO_REPLY 129 +#define ICMP6_ECHO 128 +#define ICMP6_NEIGHBOR_SOLICITATION 135 +#define ICMP6_NEIGHBOR_ADVERTISEMENT 136 + +#define ICMP6_FLAG_S (1 << 6) + +#define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1 +#define ICMP6_OPTION_TARGET_LINK_ADDRESS 2 + /**************************************************************************** * Public Type Definitions ****************************************************************************/ @@ -70,6 +101,10 @@ extern const uip_ipaddr_t all_zeroes_addr; extern uint16 g_ipid; +#if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6) +extern uint8 uip_reasstmr; +#endif + /**************************************************************************** * Public Function Prototypes ****************************************************************************/ @@ -90,12 +125,43 @@ EXTERN struct uip_conn *uip_tcplistener(uint16 portno); EXTERN struct uip_conn *uip_tcpaccept(struct uip_tcpip_hdr *buf); EXTERN void uip_tcpnextsequence(void); +/* Defined in uip-tcppoll.c *************************************************/ + +EXTERN void uip_tcppoll(struct uip_driver_s *dev, struct uip_conn *conn); + +/* Defined in uip-udptimer.c ************************************************/ + +EXTERN void uip_udptimer(struct uip_driver_s *dev, struct uip_conn *conn); + /* Defined in uip_listen.c **************************************************/ EXTERN void uip_listeninit(void); EXTERN boolean uip_islistener(uint16 port); EXTERN int uip_accept(struct uip_conn *conn, uint16 portno); +/* Defined in uip-tcpsend.c *************************************************/ + +EXTERN void uip_tcpsend(struct uip_driver_s *dev, struct uip_conn *conn, + uint8 flags, uint16 len); +EXTERN void uip_tcpreset(struct uip_driver_s *dev); +EXTERN void uip_tcpack(struct uip_driver_s *dev, struct uip_conn *conn, + uint8 ack); + +/* Defined in uip-tcpappsend.c **********************************************/ + +EXTERN void uip_tcpappsend(struct uip_driver_s *dev, struct uip_conn *conn, + uint8 result); +EXTERN void uip_tcprexmit(struct uip_driver_s *dev, struct uip_conn *conn, + uint8 result); + +/* Defined in uip-tcpinput.c ************************************************/ + +EXTERN void uip_tcpinput(struct uip_driver_s *dev); + +/* Defined in uip_uipcallback.c *********************************************/ + +EXTERN void uip_tcpcallback(struct uip_driver_s *dev); + #ifdef CONFIG_NET_UDP /* Defined in uip_udpconn.c *************************************************/ @@ -103,7 +169,7 @@ EXTERN void uip_udpinit(void); EXTERN struct uip_udp_conn *uip_udpactive(struct uip_udpip_hdr *buf); EXTERN struct uip_udp_conn *uip_nextudpconn(struct uip_udp_conn *conn); -/* Defined in uip-udppool.c *************************************************/ +/* Defined in uip-udppoll.c *************************************************/ EXTERN void uip_udppoll(struct uip_driver_s *dev, struct uip_udp_conn *conn); @@ -120,6 +186,10 @@ EXTERN void uip_udpinput(struct uip_driver_s *dev); EXTERN void uip_udpcallback(struct uip_driver_s *dev); #endif /* CONFIG_NET_UDP */ +/* Defined in uip-icmpinput.c ***********************************************/ + +EXTERN void uip_icmpinput(struct uip_driver_s *dev); + /* UIP logging **************************************************************/ /* This function must be provided by the application if CONFIG_NET_LOGGING diff --git a/nuttx/net/uip/uip-poll.c b/nuttx/net/uip/uip-poll.c index 19dc16a5a..0ac8fac97 100644 --- a/nuttx/net/uip/uip-poll.c +++ b/nuttx/net/uip/uip-poll.c @@ -107,7 +107,15 @@ int uip_poll(struct uip_driver_s *dev, uip_poll_callback_t callback, int event) while ((conn = uip_nexttcpconn(conn))) { uip_conn = conn; - uip_interrupt(dev, event); + if (event == UIP_DRV_POLL) + { + uip_tcppoll(dev, conn); + } + else + { + uip_tcptimer(dev, conn); + } + if (callback(dev)) { irqrestore(flags); diff --git a/nuttx/net/uip/uip-setipid.c b/nuttx/net/uip/uip-setipid.c new file mode 100644 index 000000000..71467b0f8 --- /dev/null +++ b/nuttx/net/uip/uip-setipid.c @@ -0,0 +1,78 @@ +/**************************************************************************** + * net/uip/uip-udpcallback.c + * + * Copyright (C) 2007 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#ifdef CONFIG_NET + +#include +#include + +#include + +#include "uip-internal.h" + +/**************************************************************************** + * Private Data + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Function: uip_setipid + * + * Description: + * This function may be used at boot time to set the initial ip_id. + * + * Assumptions: + * + ****************************************************************************/ + +void uip_setipid(uint16 id) +{ + g_ipid = id; +} + +#endif /* CONFIG_NET */ diff --git a/nuttx/net/uip/uip-split.c b/nuttx/net/uip/uip-split.c index 8488bd3d1..8d75487d2 100644 --- a/nuttx/net/uip/uip-split.c +++ b/nuttx/net/uip/uip-split.c @@ -102,18 +102,16 @@ void uip_split_output(struct uip_driver_s *dev) /* dev->d_appdata += len1;*/ memcpy(dev->d_appdata, dev->d_appdata + len1, len2); - uip_add32(BUF->seqno, len1); - BUF->seqno[0] = uip_acc32[0]; - BUF->seqno[1] = uip_acc32[1]; - BUF->seqno[2] = uip_acc32[2]; - BUF->seqno[3] = uip_acc32[3]; + uip_incr32(BUF->seqno, len1); /* Recalculate the TCP checksum. */ + BUF->tcpchksum = 0; BUF->tcpchksum = ~(uip_tcpchksum(dev)); #ifndef CONFIG_NET_IPv6 /* Recalculate the IP checksum. */ + BUF->ipchksum = 0; BUF->ipchksum = ~(uip_ipchksum(dev)); #endif /* CONFIG_NET_IPv6 */ diff --git a/nuttx/net/uip/uip-tcpappsend.c b/nuttx/net/uip/uip-tcpappsend.c new file mode 100644 index 000000000..c0bbe8b48 --- /dev/null +++ b/nuttx/net/uip/uip-tcpappsend.c @@ -0,0 +1,225 @@ +/**************************************************************************** + * net/uip/uip-tcpappsend.c + * + * Copyright (C) 2007 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Adapted for NuttX from logic in uIP which also has a BSD-like license: + * + * Original author Adam Dunkels + * Copyright () 2001-2003, Adam Dunkels. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#ifdef CONFIG_NET + +#include +#include + +#include +#include +#include + +#include "uip-internal.h" + +/**************************************************************************** + * Definitions + ****************************************************************************/ + +#define BUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN]) + +/**************************************************************************** + * Public Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: uip_tcpappsend + * + * Description: + * Handle application response + * + * Parameters: + * dev - The device driver structure to use in the send operation + * conn - The TCP connection structure holding connection information + * result - App result event sent + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +void uip_tcpappsend(struct uip_driver_s *dev, struct uip_conn *conn, uint8 result) +{ + /* Handle the result based on the application response */ + + if (result & UIP_ABORT) + { + dev->d_sndlen = 0; + conn->tcpstateflags = UIP_CLOSED; + vdbg("TCP state: UIP_CLOSED\n"); + + uip_tcpsend(dev, conn, TCP_RST | TCP_ACK, UIP_IPTCPH_LEN); + } + + else if (result & UIP_CLOSE) + { + conn->tcpstateflags = UIP_FIN_WAIT_1; + conn->len = 1; + conn->nrtx = 0; + vdbg("TCP state: UIP_FIN_WAIT_1\n"); + + dev->d_sndlen = 0; + uip_tcpsend(dev, conn, TCP_FIN | TCP_ACK, UIP_IPTCPH_LEN); + } + + /* If d_sndlen > 0, the application has data to be sent. */ + + else if (dev->d_sndlen > 0) + { + /* If the connection has acknowledged data, the contents of + * the ->len variable should be discarded. + */ + + if (result & UIP_ACKDATA) + { + conn->len = 0; + } + + /* If the ->len variable is non-zero the connection has + * already data in transit and cannot send anymore right + * now. + */ + + if (conn->len == 0) + { + /* The application cannot send more than what is + * allowed by the mss (the minumum of the MSS and the + * available window). + */ + + if (dev->d_sndlen > conn->mss) + { + dev->d_sndlen = conn->mss; + } + + /* Remember how much data we send out now so that we + * know when everything has been acknowledged. + */ + + conn->len = dev->d_sndlen; + } + else + { + /* If the application already had unacknowledged data, + * we make sure that the application does not send + * (i.e., retransmit) out more than it previously sent + * out. + */ + + dev->d_sndlen = conn->len; + } + + /* Then handle the rest of the operation just as for the rexmit case */ + + conn->nrtx = 0; + uip_tcprexmit(dev, conn, result); + } +} + +/**************************************************************************** + * Name: uip_tcprexmit + * + * Description: + * Handle application retransmission + * + * Parameters: + * dev - The device driver structure to use in the send operation + * conn - The TCP connection structure holding connection information + * result - App result event sent + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +void uip_tcprexmit(struct uip_driver_s *dev, struct uip_conn *conn, uint8 result) +{ + dev->d_appdata = dev->d_snddata; + + /* If the application has data to be sent, or if the incoming packet had + * new data in it, we must send out a packet. + */ + + if (dev->d_sndlen > 0 && conn->len > 0) + { + /* We always set the ACK flag in response packets adding the length of + * the IP and TCP headers. + */ + + uip_tcpsend(dev, conn, TCP_ACK | TCP_PSH, conn->len + UIP_TCPIP_HLEN); + } + + /* If there is no data to send, just send out a pure ACK if there is newdata. */ + + else if (result & UIP_NEWDATA) + { + uip_tcpsend(dev, conn, TCP_ACK, UIP_TCPIP_HLEN); + } + + /* There is nothing to do -- drop the packet */ + + else + { + dev->d_len = 0; + } +} +#endif /* CONFIG_NET */ diff --git a/nuttx/net/uip/uip-tcpcallback.c b/nuttx/net/uip/uip-tcpcallback.c new file mode 100644 index 000000000..ad1822712 --- /dev/null +++ b/nuttx/net/uip/uip-tcpcallback.c @@ -0,0 +1,105 @@ +/**************************************************************************** + * net/uip/uip-tcpcallback.c + * + * Copyright (C) 2007 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#ifdef CONFIG_NET + +#include +#include + +#include +#include +#include + +#include "uip-internal.h" + +/**************************************************************************** + * Private Data + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Function: uip_tcpcallback + * + * Description: + * Inform the application holding the TCP socket of a change in state. + * + * Assumptions: + * This function is called at the interrupt level with interrupts disabled. + * + ****************************************************************************/ + +void uip_tcpcallback(struct uip_driver_s *dev) +{ + vdbg("uip_flags: %02x\n", uip_flags); + + /* Some sanity checking */ + + if (uip_conn) + { + /* Check if there is a data callback */ + + if (uip_conn->data_event) + { + /* Perform the callback */ + + uip_conn->data_event(dev, uip_conn->data_private); + } + + /* Check if there is a connection-related event and a connection + * callback. + */ + if (((uip_flags & UIP_CONN_EVENTS) != 0) && uip_conn->connection_event) + { + /* Perform the callback */ + + uip_conn->connection_event(uip_conn->connection_private); + } + } +} + +#endif /* CONFIG_NET */ diff --git a/nuttx/net/uip/uip-tcpinput.c b/nuttx/net/uip/uip-tcpinput.c new file mode 100644 index 000000000..b8a225dbc --- /dev/null +++ b/nuttx/net/uip/uip-tcpinput.c @@ -0,0 +1,753 @@ +/**************************************************************************** + * net/uip/uip-tcpinput.c + * Handling incoming TCP input + * + * Copyright (C) 2007 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Adapted for NuttX from logic in uIP which also has a BSD-like license: + * + * Original author Adam Dunkels + * Copyright () 2001-2003, Adam Dunkels. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#ifdef CONFIG_NET + +#include +#include + +#include +#include +#include + +#include "uip-internal.h" + +/**************************************************************************** + * Definitions + ****************************************************************************/ + +#define BUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN]) + +/**************************************************************************** + * Public Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: uip_tcpinput + * + * Description: + * Handle incoming TCP input + * + * Parameters: + * dev - The device driver structure containing the received TCP packet. + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +void uip_tcpinput(struct uip_driver_s *dev) +{ + register struct uip_conn *uip_connr = uip_conn; + uint16 tmp16; + uint8 opt; + int len; + int i; + +#ifdef CONFIG_NET_STATISTICS + uip_stat.tcp.recv++; +#endif + + /* Start of TCP input header processing code. */ + + if (uip_tcpchksum(dev) != 0xffff) + { + /* Compute and check the TCP checksum. */ + +#ifdef CONFIG_NET_STATISTICS + uip_stat.tcp.drop++; + uip_stat.tcp.chkerr++; +#endif + uip_log("tcp: bad checksum."); + goto drop; + } + + /* Demultiplex this segment. First check any active connections. */ + + uip_connr = uip_tcpactive(BUF); + if (uip_connr) + { + goto found; + } + + /* If we didn't find and active connection that expected the packet, + * either (1) this packet is an old duplicate, or (2) this is a SYN packet + * destined for a connection in LISTEN. If the SYN flag isn't set, + * it is an old packet and we send a RST. + */ + + if ((BUF->flags & TCP_CTL) == TCP_SYN) + { + /* This is a SYN packet for a connection. Find the connection + * listening on this port. + */ + + tmp16 = BUF->destport; + if (uip_islistener(tmp16)) + { + /* We matched the incoming packet with a connection in LISTEN. + * We now need to create a new connection and send a SYNACK in + * response. + */ + + /* First allocate a new connection structure and see if there is any + * user application to accept it. + */ + + uip_connr = uip_tcpaccept(BUF); + if (uip_connr) + { + /* The connection structure was successfully allocated. Now see + * there is an application waiting to accept the connection (or at + * least queue it it for acceptance). + */ + + if (uip_accept(uip_connr, tmp16) != OK) + { + /* No, then we have to give the connection back */ + + uip_tcpfree(uip_connr); + uip_connr = NULL; + } + } + + if (!uip_connr) + { + /* Either (1) all available connections are in use, or (2) there is no + * application in place to accept the connection. We drop packet and hope that + * the remote end will retransmit the packet at a time when we + * have more spare connections or someone waiting to accept the connection. + */ + +#ifdef CONFIG_NET_STATISTICS + uip_stat.tcp.syndrop++; +#endif + uip_log("tcp: found no unused connections."); + goto drop; + } + + uip_incr32(uip_conn->rcv_nxt, 1); + uip_conn = uip_connr; + + /* Parse the TCP MSS option, if present. */ + + if ((BUF->tcpoffset & 0xf0) > 0x50) + { + for (i = 0; i < ((BUF->tcpoffset >> 4) - 5) << 2 ;) + { + opt = dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + i]; + if (opt == TCP_OPT_END) + { + /* End of options. */ + + break; + } + else if (opt == TCP_OPT_NOOP) + { + /* NOP option. */ + + ++i; + } + else if (opt == TCP_OPT_MSS && + dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == TCP_OPT_MSS_LEN) + { + /* An MSS option with the right option length. */ + + tmp16 = ((uint16)dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + i] << 8) | + (uint16)dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + i]; + uip_connr->initialmss = uip_connr->mss = + tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16; + + /* And we are done processing options. */ + + break; + } + else + { + /* All other options have a length field, so that we easily + * can skip past them. + */ + + if (dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == 0) + { + /* If the length field is zero, the options are malformed + * and we don't process them further. + */ + + break; + } + i += dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i]; + } + } + } + + /* Our response will be a SYNACK. */ + + uip_tcpack(dev, uip_connr, TCP_ACK | TCP_SYN); + goto done; + } + } + + /* This is (1) an old duplicate packet or (2) a SYN packet but with + * no matching listener found. Send RST packet in either case. + */ + + /* We do not send resets in response to resets. */ + + if (BUF->flags & TCP_RST) + { + goto drop; + } + +#ifdef CONFIG_NET_STATISTICS + uip_stat.tcp.synrst++; +#endif + uip_tcpreset(dev); + goto done; + +found: + + uip_conn = uip_connr; + uip_flags = 0; + + /* We do a very naive form of TCP reset processing; we just accept + * any RST and kill our connection. We should in fact check if the + * sequence number of this reset is wihtin our advertised window + * before we accept the reset. + */ + + if (BUF->flags & TCP_RST) + { + uip_connr->tcpstateflags = UIP_CLOSED; + vdbg("TCP state: UIP_CLOSED\n"); + uip_log("tcp: got reset, aborting connection."); + + uip_flags = UIP_ABORT; + uip_tcpcallback(dev); + goto drop; + } + + /* Calculated the length of the data, if the application has sent + * any data to us. + */ + + len = (BUF->tcpoffset >> 4) << 2; + + /* d_len will contain the length of the actual TCP data. This is + * calculated by subtracing the length of the TCP header (in + * len) and the length of the IP header (20 bytes). + */ + + dev->d_len -= (len + UIP_IPH_LEN); + + /* First, check if the sequence number of the incoming packet is + * what we're expecting next. If not, we send out an ACK with the + * correct numbers in. + */ + + if (!(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) && + ((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)))) + { + if ((dev->d_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0)) && + (BUF->seqno[0] != uip_connr->rcv_nxt[0] || + BUF->seqno[1] != uip_connr->rcv_nxt[1] || + BUF->seqno[2] != uip_connr->rcv_nxt[2] || + BUF->seqno[3] != uip_connr->rcv_nxt[3])) + { + uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN); + goto done; + } + } + + /* Next, check if the incoming segment acknowledges any outstanding + * data. If so, we update the sequence number, reset the length of + * the outstanding data, calculate RTT estimations, and reset the + * retransmission timer. + */ + + if ((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) + { + /* Temporary variables. */ + + uint8 acc32[4]; + uip_add32(uip_connr->snd_nxt, uip_connr->len, acc32); + + if (BUF->ackno[0] == acc32[0] && BUF->ackno[1] == acc32[1] && + BUF->ackno[2] == acc32[2] && BUF->ackno[3] == acc32[3]) + { + /* Update sequence number. */ + + uip_connr->snd_nxt[0] = acc32[0]; + uip_connr->snd_nxt[1] = acc32[1]; + uip_connr->snd_nxt[2] = acc32[2]; + uip_connr->snd_nxt[3] = acc32[3]; + + /* Do RTT estimation, unless we have done retransmissions. */ + + if (uip_connr->nrtx == 0) + { + signed char m; + m = uip_connr->rto - uip_connr->timer; + + /* This is taken directly from VJs original code in his paper */ + + m = m - (uip_connr->sa >> 3); + uip_connr->sa += m; + if (m < 0) + { + m = -m; + } + + m = m - (uip_connr->sv >> 2); + uip_connr->sv += m; + uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv; + } + + /* Set the acknowledged flag. */ + + uip_flags = UIP_ACKDATA; + + /* Reset the retransmission timer. */ + + uip_connr->timer = uip_connr->rto; + + /* Reset length of outstanding data. */ + + uip_connr->len = 0; + } + } + + /* Do different things depending on in what state the connection is. */ + + switch(uip_connr->tcpstateflags & UIP_TS_MASK) + { + /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not + * implemented, since we force the application to close when the + * peer sends a FIN (hence the application goes directly from + * ESTABLISHED to LAST_ACK). + */ + + case UIP_SYN_RCVD: + /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and + * we are waiting for an ACK that acknowledges the data we sent + * out the last time. Therefore, we want to have the UIP_ACKDATA + * flag set. If so, we enter the ESTABLISHED state. + */ + + if (uip_flags & UIP_ACKDATA) + { + uip_connr->tcpstateflags = UIP_ESTABLISHED; + uip_connr->len = 0; + vdbg("TCP state: UIP_ESTABLISHED\n"); + + uip_flags = UIP_CONNECTED; + + if (dev->d_len > 0) + { + uip_flags |= UIP_NEWDATA; + uip_incr32(uip_conn->rcv_nxt, dev->d_len); + } + + dev->d_sndlen = 0; + uip_tcpcallback(dev); + uip_tcpappsend(dev, uip_connr, uip_flags); + goto done; + } + goto drop; + + case UIP_SYN_SENT: + /* In SYN_SENT, we wait for a SYNACK that is sent in response to + * our SYN. The rcv_nxt is set to sequence number in the SYNACK + * plus one, and we send an ACK. We move into the ESTABLISHED + * state. + */ + + if ((uip_flags & UIP_ACKDATA) && + (BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)) + { + /* Parse the TCP MSS option, if present. */ + + if ((BUF->tcpoffset & 0xf0) > 0x50) + { + for (i = 0; i < ((BUF->tcpoffset >> 4) - 5) << 2 ;) + { + opt = dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + i]; + if (opt == TCP_OPT_END) + { + /* End of options. */ + + break; + } + else if (opt == TCP_OPT_NOOP) + { + /* NOP option. */ + + ++i; + } + else if (opt == TCP_OPT_MSS && + dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == TCP_OPT_MSS_LEN) + { + /* An MSS option with the right option length. */ + + tmp16 = + (dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + i] << 8) | + dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + i]; + uip_connr->initialmss = + uip_connr->mss = + tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16; + + /* And we are done processing options. */ + + break; + } + else + { + /* All other options have a length field, so that we + * easily can skip past them. + */ + + if (dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == 0) + { + /* If the length field is zero, the options are + * malformed and we don't process them further. + */ + + break; + } + i += dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i]; + } + } + } + + uip_connr->tcpstateflags = UIP_ESTABLISHED; + uip_connr->rcv_nxt[0] = BUF->seqno[0]; + uip_connr->rcv_nxt[1] = BUF->seqno[1]; + uip_connr->rcv_nxt[2] = BUF->seqno[2]; + uip_connr->rcv_nxt[3] = BUF->seqno[3]; + vdbg("TCP state: UIP_ESTABLISHED\n"); + + uip_incr32(uip_conn->rcv_nxt, 1); + uip_flags = UIP_CONNECTED | UIP_NEWDATA; + uip_connr->len = 0; + dev->d_len = 0; + dev->d_sndlen = 0; + uip_tcpcallback(dev); + uip_tcpappsend(dev, uip_connr, uip_flags); + goto done; + } + + /* Inform the application that the connection failed */ + + uip_flags = UIP_ABORT; + uip_tcpcallback(dev); + + /* The connection is closed after we send the RST */ + + uip_conn->tcpstateflags = UIP_CLOSED; + vdbg("TCP state: UIP_CLOSED\n"); + + /* We do not send resets in response to resets. */ + + if (BUF->flags & TCP_RST) + { + goto drop; + } + uip_tcpreset(dev); + goto done; + + case UIP_ESTABLISHED: + /* In the ESTABLISHED state, we call upon the application to feed + * data into the d_buf. If the UIP_ACKDATA flag is set, the + * application should put new data into the buffer, otherwise we are + * retransmitting an old segment, and the application should put that + * data into the buffer. + * + * If the incoming packet is a FIN, we should close the connection on + * this side as well, and we send out a FIN and enter the LAST_ACK + * state. We require that there is no outstanding data; otherwise the + * sequence numbers will be screwed up. + */ + + if (BUF->flags & TCP_FIN && !(uip_connr->tcpstateflags & UIP_STOPPED)) + { + if (uip_outstanding(uip_connr)) + { + goto drop; + } + + uip_incr32(uip_conn->rcv_nxt, dev->d_len + 1); + uip_flags |= UIP_CLOSE; + + if (dev->d_len > 0) + { + uip_flags |= UIP_NEWDATA; + } + + uip_tcpcallback(dev); + + uip_connr->tcpstateflags = UIP_LAST_ACK; + uip_connr->len = 1; + uip_connr->nrtx = 0; + vdbg("TCP state: UIP_LAST_ACK\n"); + + uip_tcpsend(dev, uip_connr, TCP_FIN | TCP_ACK, UIP_IPTCPH_LEN); + goto done; + } + + /* Check the URG flag. If this is set, the segment carries urgent + data that we must pass to the application. */ + if ((BUF->flags & TCP_URG) != 0) + { +#if UIP_URGDATA > 0 + uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1]; + if (uip_urglen > dev->d_len) + { + /* There is more urgent data in the next segment to come. */ + + uip_urglen = dev->d_len; + } + + uip_incr32(uip_conn->rcv_nxt, uip_urglen); + dev->d_len -= uip_urglen; + uip_urgdata = dev->d_appdata; + dev->d_appdata += uip_urglen; + } + else + { + uip_urglen = 0; +#else /* UIP_URGDATA > 0 */ + dev->d_appdata = + ((uint8*)dev->d_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]); + dev->d_len -= + (BUF->urgp[0] << 8) | BUF->urgp[1]; +#endif /* UIP_URGDATA > 0 */ + } + + /* If d_len > 0 we have TCP data in the packet, and we flag this + * by setting the UIP_NEWDATA flag and update the sequence number + * we acknowledge. If the application has stopped the dataflow + * using uip_stop(), we must not accept any data packets from the + * remote host. + */ + + if (dev->d_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) + { + uip_flags |= UIP_NEWDATA; + uip_incr32(uip_conn->rcv_nxt, dev->d_len); + } + + /* Check if the available buffer space advertised by the other end + * is smaller than the initial MSS for this connection. If so, we + * set the current MSS to the window size to ensure that the + * application does not send more data than the other end can + * handle. + * + * If the remote host advertises a zero window, we set the MSS to + * the initial MSS so that the application will send an entire MSS + * of data. This data will not be acknowledged by the receiver, + * and the application will retransmit it. This is called the + * "persistent timer" and uses the retransmission mechanim. + */ + + tmp16 = ((uint16)BUF->wnd[0] << 8) + (uint16)BUF->wnd[1]; + if (tmp16 > uip_connr->initialmss || tmp16 == 0) + { + tmp16 = uip_connr->initialmss; + } + uip_connr->mss = tmp16; + + /* If this packet constitutes an ACK for outstanding data (flagged + * by the UIP_ACKDATA flag, we should call the application since it + * might want to send more data. If the incoming packet had data + * from the peer (as flagged by the UIP_NEWDATA flag), the + * application must also be notified. + * + * When the application is called, the d_len field + * contains the length of the incoming data. The application can + * access the incoming data through the global pointer + * d_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN + * bytes into the d_buf array. + * + * If the application wishes to send any data, this data should be + * put into the d_appdata and the length of the data should be + * put into d_len. If the application don't have any data to + * send, d_len must be set to 0. + */ + + if (uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) + { + dev->d_sndlen = 0; + uip_tcpcallback(dev); + uip_tcpappsend(dev, uip_connr, uip_flags); + goto done; + } + goto drop; + + case UIP_LAST_ACK: + /* We can close this connection if the peer has acknowledged our + * FIN. This is indicated by the UIP_ACKDATA flag. + */ + + if (uip_flags & UIP_ACKDATA) + { + uip_connr->tcpstateflags = UIP_CLOSED; + vdbg("TCP state: UIP_CLOSED\n"); + + uip_flags = UIP_CLOSE; + uip_tcpcallback(dev); + } + break; + + case UIP_FIN_WAIT_1: + /* The application has closed the connection, but the remote host + * hasn't closed its end yet. Thus we do nothing but wait for a + * FIN from the other side. + */ + + if (dev->d_len > 0) + { + uip_incr32(uip_conn->rcv_nxt, dev->d_len); + } + if (BUF->flags & TCP_FIN) + { + if (uip_flags & UIP_ACKDATA) + { + uip_connr->tcpstateflags = UIP_TIME_WAIT; + uip_connr->timer = 0; + uip_connr->len = 0; + vdbg("TCP state: UIP_TIME_WAIT\n"); + } + else + { + uip_connr->tcpstateflags = UIP_CLOSING; + vdbg("TCP state: UIP_CLOSING\n"); + } + + uip_incr32(uip_conn->rcv_nxt, 1); + uip_flags = UIP_CLOSE; + uip_tcpcallback(dev); + uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN); + goto done; + } + else if (uip_flags & UIP_ACKDATA) + { + uip_connr->tcpstateflags = UIP_FIN_WAIT_2; + uip_connr->len = 0; + vdbg("TCP state: UIP_FIN_WAIT_2\n"); + goto drop; + } + + if (dev->d_len > 0) + { + uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN); + goto done; + } + goto drop; + + case UIP_FIN_WAIT_2: + if (dev->d_len > 0) + { + uip_incr32(uip_conn->rcv_nxt, dev->d_len); + } + + if (BUF->flags & TCP_FIN) + { + uip_connr->tcpstateflags = UIP_TIME_WAIT; + uip_connr->timer = 0; + vdbg("TCP state: UIP_TIME_WAIT\n"); + + uip_incr32(uip_conn->rcv_nxt, 1); + uip_flags = UIP_CLOSE; + uip_tcpcallback(dev); + uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN); + goto done; + } + + if (dev->d_len > 0) + { + uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN); + goto done; + } + goto drop; + + case UIP_TIME_WAIT: + uip_tcpsend(dev, uip_connr, TCP_ACK, UIP_IPTCPH_LEN); + goto done; + + case UIP_CLOSING: + if (uip_flags & UIP_ACKDATA) + { + uip_connr->tcpstateflags = UIP_TIME_WAIT; + uip_connr->timer = 0; + vdbg("TCP state: UIP_TIME_WAIT\n"); + } + } + goto drop; + +done: + uip_flags = 0; + return; + +drop: + uip_flags = 0; + dev->d_len = 0; +} + +#endif /* CONFIG_NET */ diff --git a/nuttx/net/uip/uip-tcppoll.c b/nuttx/net/uip/uip-tcppoll.c new file mode 100644 index 000000000..625b91931 --- /dev/null +++ b/nuttx/net/uip/uip-tcppoll.c @@ -0,0 +1,126 @@ +/**************************************************************************** + * net/uip/uip-tcppoll.c + * Poll for the availability of TCP TX data + * + * Copyright (C) 2007 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Adapted for NuttX from logic in uIP which also has a BSD-like license: + * + * Original author Adam Dunkels + * Copyright () 2001-2003, Adam Dunkels. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#ifdef CONFIG_NET + +#include +#include + +#include +#include +#include + +#include "uip-internal.h" + +/**************************************************************************** + * Definitions + ****************************************************************************/ + +/**************************************************************************** + * Public Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: uip_tcppoll + * + * Description: + * Poll a TCP connection structure for availability of TX data + * + * Parameters: + * dev - The device driver structure to use in the send operation + * conn - The TCP "connection" to poll for TX data + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +void uip_tcppoll(struct uip_driver_s *dev, struct uip_conn *conn) +{ + /* Verify that the connection is established and if the connection has + * oustanding (unacknowledged) sent data. + */ + + if ((conn->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED && + !uip_outstanding(conn)) + { + /* Set up for the callback */ + + dev->d_snddata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN]; + dev->d_appdata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN]; + + /* Perfom the callback */ + + uip_flags = UIP_POLL; + uip_tcpcallback(dev); + + /* Handle the callback response */ + + uip_tcpappsend(dev, conn, uip_flags); + } + else + { + /* Nothing to do for this connection */ + + dev->d_len = 0; + } +} + +#endif /* CONFIG_NET */ diff --git a/nuttx/net/uip/uip-tcpsend.c b/nuttx/net/uip/uip-tcpsend.c new file mode 100644 index 000000000..9c367159d --- /dev/null +++ b/nuttx/net/uip/uip-tcpsend.c @@ -0,0 +1,365 @@ +/**************************************************************************** + * net/uip/uip-tcpsend.c + * + * Copyright (C) 2007 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Adapted for NuttX from logic in uIP which also has a BSD-like license: + * + * Original author Adam Dunkels + * Copyright () 2001-2003, Adam Dunkels. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#ifdef CONFIG_NET + +#include +#include + +#include +#include +#include + +#include "uip-internal.h" + +/**************************************************************************** + * Definitions + ****************************************************************************/ + +#define BUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN]) + +/**************************************************************************** + * Public Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: uip_tcpsendcomplete + * + * Description: + * Complete the final portions of the send operation. This function sets + * up IP header and computes the TCP checksum + * + * Parameters: + * dev - The device driver structure to use in the send operation + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +static void uip_tcpsendcomplete(struct uip_driver_s *dev) +{ + BUF->ttl = UIP_TTL; + +#ifdef CONFIG_NET_IPv6 + + /* For IPv6, the IP length field does not include the IPv6 IP header + * length. + */ + + BUF->len[0] = ((dev->d_len - UIP_IPH_LEN) >> 8); + BUF->len[1] = ((dev->d_len - UIP_IPH_LEN) & 0xff); + +#else /* CONFIG_NET_IPv6 */ + + BUF->len[0] = (dev->d_len >> 8); + BUF->len[1] = (dev->d_len & 0xff); + +#endif /* CONFIG_NET_IPv6 */ + + BUF->urgp[0] = BUF->urgp[1] = 0; + + /* Calculate TCP checksum. */ + + BUF->tcpchksum = 0; + BUF->tcpchksum = ~(uip_tcpchksum(dev)); + +#ifdef CONFIG_NET_IPv6 + + BUF->vtc = 0x60; + BUF->tcf = 0x00; + BUF->flow = 0x00; + +#else /* CONFIG_NET_IPv6 */ + + BUF->vhl = 0x45; + BUF->tos = 0; + BUF->ipoffset[0] = 0; + BUF->ipoffset[1] = 0; + ++g_ipid; + BUF->ipid[0] = g_ipid >> 8; + BUF->ipid[1] = g_ipid & 0xff; + + /* Calculate IP checksum. */ + + BUF->ipchksum = 0; + BUF->ipchksum = ~(uip_ipchksum(dev)); + +#endif /* CONFIG_NET_IPv6 */ + + vdbg("Outgoing TCP packet length: %d (%d)\n", + dev->d_len, (BUF->len[0] << 8) | BUF->len[1]); + +#ifdef CONFIG_NET_STATISTICS + uip_stat.tcp.sent++; + uip_stat.ip.sent++; +#endif +} + +/**************************************************************************** + * Name: uip_tcpsendcommon + * + * Description: + * We're done with the input processing. We are now ready to send a reply + * Our job is to fill in all the fields of the TCP and IP headers before + * calculating the checksum and finally send the packet. + * + * Parameters: + * dev - The device driver structure to use in the send operation + * conn - The TCP connection structure holding connection information + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +static void uip_tcpsendcommon(struct uip_driver_s *dev, struct uip_conn *conn) +{ + BUF->ackno[0] = conn->rcv_nxt[0]; + BUF->ackno[1] = conn->rcv_nxt[1]; + BUF->ackno[2] = conn->rcv_nxt[2]; + BUF->ackno[3] = conn->rcv_nxt[3]; + + BUF->seqno[0] = conn->snd_nxt[0]; + BUF->seqno[1] = conn->snd_nxt[1]; + BUF->seqno[2] = conn->snd_nxt[2]; + BUF->seqno[3] = conn->snd_nxt[3]; + + BUF->proto = UIP_PROTO_TCP; + + BUF->srcport = conn->lport; + BUF->destport = conn->rport; + + uiphdr_ipaddr_copy(BUF->srcipaddr, &dev->d_ipaddr); + uiphdr_ipaddr_copy(BUF->destipaddr, &conn->ripaddr); + + if (conn->tcpstateflags & UIP_STOPPED) + { + /* If the connection has issued uip_stop(), we advertise a zero + * window so that the remote host will stop sending data. + */ + + BUF->wnd[0] = 0; + BUF->wnd[1] = 0; + } + else + { + BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8); + BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff); + } + + /* Finish the IP portion of the message, calculate checksums and send + * the message. + */ + + uip_tcpsendcomplete(dev); + +} + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: uip_tcpsend + * + * Description: + * Setup to send a TCP packet + * + * Parameters: + * dev - The device driver structure to use in the send operation + * conn - The TCP connection structure holding connection information + * flags - flags to apply to the TCP header + * len - length of the message + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +void uip_tcpsend(struct uip_driver_s *dev, struct uip_conn *conn, uint8 flags, uint16 len) +{ + BUF->flags = flags; + dev->d_len = len; + BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4; + uip_tcpsendcommon(dev, conn); +} + +/**************************************************************************** + * Name: uip_tcpreset + * + * Description: + * Send a TCP reset (no-data) message + * + * Parameters: + * dev - The device driver structure to use in the send operation + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +void uip_tcpreset(struct uip_driver_s *dev) +{ + uint16 tmp16; + uint8 seqbyte; + +#ifdef CONFIG_NET_STATISTICS + uip_stat.tcp.rst++; +#endif + + BUF->flags = TCP_RST | TCP_ACK; + dev->d_len = UIP_IPTCPH_LEN; + BUF->tcpoffset = 5 << 4; + + /* Flip the seqno and ackno fields in the TCP header. */ + + seqbyte = BUF->seqno[3]; + BUF->seqno[3] = BUF->ackno[3]; + BUF->ackno[3] = seqbyte; + + seqbyte = BUF->seqno[2]; + BUF->seqno[2] = BUF->ackno[2]; + BUF->ackno[2] = seqbyte; + + seqbyte = BUF->seqno[1]; + BUF->seqno[1] = BUF->ackno[1]; + BUF->ackno[1] = seqbyte; + + seqbyte = BUF->seqno[0]; + BUF->seqno[0] = BUF->ackno[0]; + BUF->ackno[0] = seqbyte; + + /* We also have to increase the sequence number we are + * acknowledging. If the least significant byte overflowed, we need + * to propagate the carry to the other bytes as well. + */ + + if (++(BUF->ackno[3]) == 0) + { + if (++(BUF->ackno[2]) == 0) + { + if (++(BUF->ackno[1]) == 0) + { + ++(BUF->ackno[0]); + } + } + } + + /* Swap port numbers. */ + + tmp16 = BUF->srcport; + BUF->srcport = BUF->destport; + BUF->destport = tmp16; + + /* Swap IP addresses. */ + + uiphdr_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr); + uiphdr_ipaddr_copy(BUF->srcipaddr, dev->d_ipaddr); + + /* And send out the RST packet */ + + uip_tcpsendcomplete(dev); +} + +/**************************************************************************** + * Name: uip_tcpack + * + * Description: + * Send the SYN or SYNACK response. + * + * Parameters: + * dev - The device driver structure to use in the send operation + * conn - The TCP connection structure holding connection information + * ack - The ACK response to send + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +void uip_tcpack(struct uip_driver_s *dev, struct uip_conn *conn, uint8 ack) +{ + /* Save the ACK bits */ + + BUF->flags = ack; + + /* We send out the TCP Maximum Segment Size option with our ack. */ + + BUF->optdata[0] = TCP_OPT_MSS; + BUF->optdata[1] = TCP_OPT_MSS_LEN; + BUF->optdata[2] = (UIP_TCP_MSS) / 256; + BUF->optdata[3] = (UIP_TCP_MSS) & 255; + dev->d_len = UIP_IPTCPH_LEN + TCP_OPT_MSS_LEN; + BUF->tcpoffset = ((UIP_TCPH_LEN + TCP_OPT_MSS_LEN) / 4) << 4; + + /* Complete the common portions of the TCP message */ + + uip_tcpsendcommon(dev, conn); +} + +#endif /* CONFIG_NET */ diff --git a/nuttx/net/uip/uip-tcptimer.c b/nuttx/net/uip/uip-tcptimer.c new file mode 100644 index 000000000..5b248f358 --- /dev/null +++ b/nuttx/net/uip/uip-tcptimer.c @@ -0,0 +1,241 @@ +/**************************************************************************** + * net/uip/uip-tcptimer.c + * Poll for the availability of TCP TX data + * + * Copyright (C) 2007 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Adapted for NuttX from logic in uIP which also has a BSD-like license: + * + * Original author Adam Dunkels + * Copyright () 2001-2003, Adam Dunkels. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#ifdef CONFIG_NET + +#include +#include + +#include +#include +#include + +#include "uip-internal.h" + +/**************************************************************************** + * Definitions + ****************************************************************************/ + +/**************************************************************************** + * Public Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Variables + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: uip_tcptimer + * + * Description: + * Handle a TCP timer expiration for the provided TCP connection + * + * Parameters: + * dev - The device driver structure to use in the send operation + * conn - The TCP "connection" to poll for TX data + * + * Return: + * None + * + * Assumptions: + * Called from the interrupt level or with interrupts disabled. + * + ****************************************************************************/ + +void uip_tcptimer(struct uip_driver_s *dev, struct uip_conn *conn) +{ + dev->d_snddata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN]; + dev->d_appdata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN]; + + /* Increment the timer used by the reassembly logic */ + +#if UIP_REASSEMBLY + if (uip_reasstmr != 0) + { + uip_reasstmr++; + } +#endif /* UIP_REASSEMBLY */ + + /* Increase the TCP sequence number */ + + uip_tcpnextsequence(); + + /* Reset the length variables. */ + + dev->d_len = 0; + dev->d_sndlen = 0; + + /* Check if the connection is in a state in which we simply wait + * for the connection to time out. If so, we increase the + * connection's timer and remove the connection if it times + * out. + */ + + if (conn->tcpstateflags == UIP_TIME_WAIT || conn->tcpstateflags == UIP_FIN_WAIT_2) + { + (conn->timer)++; + if (conn->timer == UIP_TIME_WAIT_TIMEOUT) + { + conn->tcpstateflags = UIP_CLOSED; + vdbg("TCP state: UIP_CLOSED\n"); + } + } + else if (conn->tcpstateflags != UIP_CLOSED) + { + /* If the connection has outstanding data, we increase the + * connection's timer and see if it has reached the RTO value + * in which case we retransmit. + */ + + if (uip_outstanding(conn)) + { + if (conn->timer-- == 0) + { + if (conn->nrtx == UIP_MAXRTX || + ((conn->tcpstateflags == UIP_SYN_SENT || + conn->tcpstateflags == UIP_SYN_RCVD) && + conn->nrtx == UIP_MAXSYNRTX)) + { + conn->tcpstateflags = UIP_CLOSED; + vdbg("TCP state: UIP_CLOSED\n"); + + /* We call uip_tcpcallback() with uip_flags set to + * UIP_TIMEDOUT to inform the application that the + * connection has timed out. + */ + + uip_flags = UIP_TIMEDOUT; + uip_tcpcallback(dev); + + /* We also send a reset packet to the remote host. */ + + uip_tcpsend(dev, conn, TCP_RST | TCP_ACK, UIP_IPTCPH_LEN); + goto done; + } + + /* Exponential backoff. */ + + conn->timer = UIP_RTO << (conn->nrtx > 4 ? 4: conn->nrtx); + ++(conn->nrtx); + + /* Ok, so we need to retransmit. We do this differently + * depending on which state we are in. In ESTABLISHED, we + * call upon the application so that it may prepare the + * data for the retransmit. In SYN_RCVD, we resend the + * SYNACK that we sent earlier and in LAST_ACK we have to + * retransmit our FINACK. + */ + +#ifdef CONFIG_NET_STATISTICS + uip_stat.tcp.rexmit++; +#endif + switch(conn->tcpstateflags & UIP_TS_MASK) + { + case UIP_SYN_RCVD: + /* In the SYN_RCVD state, we should retransmit our + * SYNACK. + */ + + uip_tcpack(dev, conn, TCP_ACK | TCP_SYN); + goto done; + + case UIP_SYN_SENT: + /* In the SYN_SENT state, we retransmit out SYN. */ + + uip_tcpack(dev, conn, TCP_SYN); + goto done; + + case UIP_ESTABLISHED: + /* In the ESTABLISHED state, we call upon the application + * to do the actual retransmit after which we jump into + * the code for sending out the packet. + */ + + uip_flags = UIP_REXMIT; + uip_tcpcallback(dev); + uip_tcprexmit(dev, conn, uip_flags); + goto done; + + case UIP_FIN_WAIT_1: + case UIP_CLOSING: + case UIP_LAST_ACK: + /* In all these states we should retransmit a FINACK. */ + + uip_tcpsend(dev, conn, TCP_FIN | TCP_ACK, UIP_IPTCPH_LEN); + goto done; + } + } + } + else if ((conn->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED) + { + /* If there was no need for a retransmission, we poll the + * application for new data. + */ + + uip_flags = UIP_POLL; + uip_tcpcallback(dev); + uip_tcpappsend(dev, conn, uip_flags); + goto done; + } + } + + /* Nothing to be done */ + + dev->d_len = 0; + +done: + uip_flags = 0; + return; +} + +#endif /* CONFIG_NET */ diff --git a/nuttx/net/uip/uip-udpsend.c b/nuttx/net/uip/uip-udpsend.c index 207c0ea35..7a2a0547c 100644 --- a/nuttx/net/uip/uip-udpsend.c +++ b/nuttx/net/uip/uip-udpsend.c @@ -1,6 +1,5 @@ /**************************************************************************** * net/uip/uip-udpsend.c - * Poll for the availability of UDP TX data * * Copyright (C) 2007 Gregory Nutt. All rights reserved. * Author: Gregory Nutt @@ -115,8 +114,8 @@ void uip_udpsend(struct uip_driver_s *dev, struct uip_udp_conn *conn) UDPBUF->flow = 0x00; UDPBUF->len[0] = (dev->d_sndlen >> 8); UDPBUF->len[1] = (dev->d_sndlen & 0xff); - UDPBUF->proto = UIP_PROTO_UDP; - UDPBUF->ttl = conn->ttl; + UDPBUF->nexthdr = UIP_PROTO_UDP; + UDPBUF->hoplimit = conn->ttl; uip_ipaddr_copy(UDPBUF->srcipaddr, &dev->d_ipaddr); uip_ipaddr_copy(UDPBUF->destipaddr, &conn->ripaddr); diff --git a/nuttx/net/uip/uip.c b/nuttx/net/uip/uip.c deleted file mode 100644 index 7c9a997b6..000000000 --- a/nuttx/net/uip/uip.c +++ /dev/null @@ -1,1767 +0,0 @@ -/**************************************************************************** - * uip.c - * The uIP TCP/IP stack code. - * author Adam Dunkels - * - * uIP is an implementation of the TCP/IP protocol stack intended for - * small 8-bit and 16-bit microcontrollers. - * - * uIP provides the necessary protocols for Internet communication, - * with a very small code footprint and RAM requirements - the uIP - * code size is on the order of a few kilobytes and RAM usage is on - * the order of a few hundred bytes. - * - * Copyright () 2001-2003, Adam Dunkels. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. The name of the author may not be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS - * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - ****************************************************************************/ - -/**************************************************************************** - * uIP is a small implementation of the IP, UDP and TCP protocols (as - * well as some basic ICMP stuff). The implementation couples the IP, - * UDP, TCP and the application layers very tightly. To keep the size - * of the compiled code down, this code frequently uses the goto - * statement. While it would be possible to break the uip_interrupt() - * function into many smaller functions, this would increase the code - * size because of the overhead of parameter passing and the fact that - * the optimier would not be as efficient. - * - * The principle is that we have a small buffer, called the d_buf, - * in which the device driver puts an incoming packet. The TCP/IP - * stack parses the headers in the packet, and calls the - * application. If the remote host has sent data to the application, - * this data is present in the d_buf and the application read the - * data from there. It is up to the application to put this data into - * a byte stream if needed. The application will not be fed with data - * that is out of sequence. - * - * If the application whishes to send data to the peer, it should put - * its data into the d_buf. The d_appdata pointer points to the - * first available byte. The TCP/IP stack will calculate the - * checksums, and fill in the necessary header fields and finally send - * the packet back to the peer. - * - ****************************************************************************/ - -/**************************************************************************** - * Included Files - ****************************************************************************/ - -#include -#ifdef CONFIG_NET - -#include -#include - -#include -#include - -#include -#include -#include - -#ifdef CONFIG_NET_IPv6 -# include "uip-neighbor.h" -#endif /* CONFIG_NET_IPv6 */ - -#include "uip-internal.h" - -/**************************************************************************** - * Definitions - ****************************************************************************/ - -#define TCP_FIN 0x01 -#define TCP_SYN 0x02 -#define TCP_RST 0x04 -#define TCP_PSH 0x08 -#define TCP_ACK 0x10 -#define TCP_URG 0x20 -#define TCP_CTL 0x3f - -#define TCP_OPT_END 0 /* End of TCP options list */ -#define TCP_OPT_NOOP 1 /* "No-operation" TCP option */ -#define TCP_OPT_MSS 2 /* Maximum segment size TCP option */ - -#define TCP_OPT_MSS_LEN 4 /* Length of TCP MSS option. */ - -#define ICMP_ECHO_REPLY 0 -#define ICMP_ECHO 8 - -#define ICMP6_ECHO_REPLY 129 -#define ICMP6_ECHO 128 -#define ICMP6_NEIGHBOR_SOLICITATION 135 -#define ICMP6_NEIGHBOR_ADVERTISEMENT 136 - -#define ICMP6_FLAG_S (1 << 6) - -#define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1 -#define ICMP6_OPTION_TARGET_LINK_ADDRESS 2 - -/* Macros. */ - -#define BUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN]) -#define FBUF ((struct uip_tcpip_hdr *)&uip_reassbuf[0]) -#define ICMPBUF ((struct uip_icmpip_hdr *)&dev->d_buf[UIP_LLH_LEN]) - -/**************************************************************************** - * Public Variables - ****************************************************************************/ - -#if UIP_URGDATA > 0 -void *uip_urgdata; /* urgent data (out-of-band data), if present. */ -uint16 uip_urglen; /* Length of (received) urgent data */ -#endif - -/* The uip_flags variable is used for communication between the TCP/IP - * stack and the application program. - */ - -uint8 uip_flags; - -/* uip_conn always points to the current connection. */ - -struct uip_conn *uip_conn; - -#ifdef CONFIG_NET_UDP -struct uip_udp_conn *uip_udp_conn; -#endif /* CONFIG_NET_UDP */ - -/* Temporary variables. */ - -uint8 uip_acc32[4]; - -#ifdef CONFIG_NET_STATISTICS -struct uip_stats uip_stat; -# define UIP_STAT(s) s -#else -# define UIP_STAT(s) -#endif - -/* Increasing number used for the IP ID field. */ - -uint16 g_ipid; - -const uip_ipaddr_t all_ones_addr = -#ifdef CONFIG_NET_IPv6 - {0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff}; -#else /* CONFIG_NET_IPv6 */ - {0xffffffff}; -#endif /* CONFIG_NET_IPv6 */ - -const uip_ipaddr_t all_zeroes_addr = -#ifdef CONFIG_NET_IPv6 - {0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000}; -#else /* CONFIG_NET_IPv6 */ - {0x00000000}; -#endif /* CONFIG_NET_IPv6 */ - -/**************************************************************************** - * Private Variables - ****************************************************************************/ - -/**************************************************************************** - * Private Functions - ****************************************************************************/ - -/**************************************************************************** - * Public Functions - ****************************************************************************/ - -/* This function may be used at boot time to set the initial ip_id.*/ - -void uip_setipid(uint16 id) -{ - g_ipid = id; -} - -/* IP fragment reassembly: not well-tested. */ - -#if UIP_REASSEMBLY && !defined(CONFIG_NET_IPv6) -#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN) -static uint8 uip_reassbuf[UIP_REASS_BUFSIZE]; -static uint8 uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)]; -static const uint8 bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01}; -static uint16 uip_reasslen; -static uint8 uip_reassflags; -#define UIP_REASS_FLAG_LASTFRAG 0x01 -static uint8 uip_reasstmr; - -#define IP_MF 0x20 - -static uint8 uip_reass(void) -{ - uint16 offset, len; - uint16 i; - - /* If ip_reasstmr is zero, no packet is present in the buffer, so we - * write the IP header of the fragment into the reassembly - * buffer. The timer is updated with the maximum age. - */ - - if (uip_reasstmr == 0) - { - memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN); - uip_reasstmr = UIP_REASS_MAXAGE; - uip_reassflags = 0; - - /* Clear the bitmap. */ - memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap)); - } - - /* Check if the incoming fragment matches the one currently present - * in the reasembly buffer. If so, we proceed with copying the - * fragment into the buffer. - */ - - if (uiphdr_addr_cmp(BUF->srcipaddr, FBUF->srcipaddr) && - uiphdr_addr_cmp(BUF->destipaddr == FBUF->destipaddr) && - BUF->g_ipid[0] == FBUF->g_ipid[0] && BUF->g_ipid[1] == FBUF->g_ipid[1]) - { - len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4; - offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8; - - /* If the offset or the offset + fragment length overflows the - * reassembly buffer, we discard the entire packet. - */ - - if (offset > UIP_REASS_BUFSIZE || offset + len > UIP_REASS_BUFSIZE) - { - uip_reasstmr = 0; - goto nullreturn; - } - - /* Copy the fragment into the reassembly buffer, at the right offset. */ - - memcpy(&uip_reassbuf[UIP_IPH_LEN + offset], (char *)BUF + (int)((BUF->vhl & 0x0f) * 4), len); - - /* Update the bitmap. */ - - if (offset / (8 * 8) == (offset + len) / (8 * 8)) - { - /* If the two endpoints are in the same byte, we only update that byte. */ - - uip_reassbitmap[offset / (8 * 8)] |= - bitmap_bits[(offset / 8 ) & 7] & ~bitmap_bits[((offset + len) / 8 ) & 7]; - - } - else - { - /* If the two endpoints are in different bytes, we update the bytes - * in the endpoints and fill the stuff inbetween with 0xff. - */ - - uip_reassbitmap[offset / (8 * 8)] |= bitmap_bits[(offset / 8 ) & 7]; - for (i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) - { - uip_reassbitmap[i] = 0xff; - } - uip_reassbitmap[(offset + len) / (8 * 8)] |= ~bitmap_bits[((offset + len) / 8 ) & 7]; - } - - /* If this fragment has the More Fragments flag set to zero, we know that - * this is the last fragment, so we can calculate the size of the entire - * packet. We also set the IP_REASS_FLAG_LASTFRAG flag to indicate that - * we have received the final fragment. - */ - - if ((BUF->ipoffset[0] & IP_MF) == 0) - { - uip_reassflags |= UIP_REASS_FLAG_LASTFRAG; - uip_reasslen = offset + len; - } - - /* Finally, we check if we have a full packet in the buffer. We do this - * by checking if we have the last fragment and if all bits in the bitmap - * are set. - */ - - if (uip_reassflags & UIP_REASS_FLAG_LASTFRAG) - { - /* Check all bytes up to and including all but the last byte in - * the bitmap. - */ - - for (i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) - { - if (uip_reassbitmap[i] != 0xff) - { - goto nullreturn; - } - } - - /* Check the last byte in the bitmap. It should contain just the - * right amount of bits. - */ - - if (uip_reassbitmap[uip_reasslen / (8 * 8)] != (uint8)~bitmap_bits[uip_reasslen / 8 & 7]) - { - goto nullreturn; - } - - /* If we have come this far, we have a full packet in the buffer, - * so we allocate a pbuf and copy the packet into it. We also reset - * the timer. - */ - - uip_reasstmr = 0; - memcpy(BUF, FBUF, uip_reasslen); - - /* Pretend to be a "normal" (i.e., not fragmented) IP packet from - * now on. - */ - - BUF->ipoffset[0] = BUF->ipoffset[1] = 0; - BUF->len[0] = uip_reasslen >> 8; - BUF->len[1] = uip_reasslen & 0xff; - BUF->ipchksum = 0; - BUF->ipchksum = ~(uip_ipchksum(dev)); - - return uip_reasslen; - } - } - -nullreturn: - return 0; -} -#endif /* UIP_REASSEMBLY */ - -static void uip_add_rcv_nxt(uint16 n) -{ - uip_add32(uip_conn->rcv_nxt, n); - uip_conn->rcv_nxt[0] = uip_acc32[0]; - uip_conn->rcv_nxt[1] = uip_acc32[1]; - uip_conn->rcv_nxt[2] = uip_acc32[2]; - uip_conn->rcv_nxt[3] = uip_acc32[3]; -} - -static void uip_tcp_callback(struct uip_driver_s *dev) -{ - vdbg("uip_flags: %02x\n", uip_flags); - - /* Some sanity checking */ - - if (uip_conn) - { - /* Check if there is a data callback */ - - if (uip_conn->data_event) - { - /* Perform the callback */ - - uip_conn->data_event(dev, uip_conn->data_private); - } - - /* Check if there is a connection-related event and a connection - * callback. - */ - if (((uip_flags & UIP_CONN_EVENTS) != 0) && uip_conn->connection_event) - { - /* Perform the callback */ - - uip_conn->connection_event(uip_conn->connection_private); - } - } -} - -void uip_interrupt(struct uip_driver_s *dev, uint8 event) -{ - register struct uip_conn *uip_connr = uip_conn; - uint16 tmp16; - uint8 seqbyte; - uint8 opt; - int len; - int i; - - vdbg("event: %d\n", event); - - dev->d_snddata = dev->d_appdata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN]; - - /* Check if we were invoked because of a TX poll request for a - * particular TCP connection. - */ - - if (event == UIP_DRV_POLL) - { - if ((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED && - !uip_outstanding(uip_connr)) - { - uip_flags = UIP_POLL; - uip_tcp_callback(dev); - goto appsend; - } - goto drop; - } - - /* Check if we were invoked because of the perodic timer firing. */ - - else if (event == UIP_DRV_TIMER) - { -#if UIP_REASSEMBLY - if (uip_reasstmr != 0) - { - --uip_reasstmr; - } -#endif /* UIP_REASSEMBLY */ - - /* Increase the TCP sequence number */ - - uip_tcpnextsequence(); - - /* Reset the length variables. */ - - dev->d_len = 0; - dev->d_sndlen = 0; - - /* Check if the connection is in a state in which we simply wait - * for the connection to time out. If so, we increase the - * connection's timer and remove the connection if it times - * out. - */ - - if (uip_connr->tcpstateflags == UIP_TIME_WAIT || - uip_connr->tcpstateflags == UIP_FIN_WAIT_2) - { - ++(uip_connr->timer); - if (uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) - { - uip_connr->tcpstateflags = UIP_CLOSED; - vdbg("TCP state: UIP_CLOSED\n"); - } - } - else if (uip_connr->tcpstateflags != UIP_CLOSED) - { - /* If the connection has outstanding data, we increase the - * connection's timer and see if it has reached the RTO value - * in which case we retransmit. - */ - - if (uip_outstanding(uip_connr)) - { - if (uip_connr->timer-- == 0) - { - if (uip_connr->nrtx == UIP_MAXRTX || - ((uip_connr->tcpstateflags == UIP_SYN_SENT || - uip_connr->tcpstateflags == UIP_SYN_RCVD) && - uip_connr->nrtx == UIP_MAXSYNRTX)) - { - uip_connr->tcpstateflags = UIP_CLOSED; - vdbg("TCP state: UIP_CLOSED\n"); - - /* We call uip_tcp_callback() with uip_flags set to - * UIP_TIMEDOUT to inform the application that the - * connection has timed out. - */ - - uip_flags = UIP_TIMEDOUT; - uip_tcp_callback(dev); - - /* We also send a reset packet to the remote host. */ - - BUF->flags = TCP_RST | TCP_ACK; - goto tcp_send_nodata; - } - - /* Exponential backoff. */ - - uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4 ? 4: uip_connr->nrtx); - ++(uip_connr->nrtx); - - /* Ok, so we need to retransmit. We do this differently - * depending on which state we are in. In ESTABLISHED, we - * call upon the application so that it may prepare the - * data for the retransmit. In SYN_RCVD, we resend the - * SYNACK that we sent earlier and in LAST_ACK we have to - * retransmit our FINACK. - */ - - UIP_STAT(++uip_stat.tcp.rexmit); - switch(uip_connr->tcpstateflags & UIP_TS_MASK) - { - case UIP_SYN_RCVD: - /* In the SYN_RCVD state, we should retransmit our - * SYNACK. - */ - - goto tcp_send_synack; - - case UIP_SYN_SENT: - /* In the SYN_SENT state, we retransmit out SYN. */ - - BUF->flags = 0; - goto tcp_send_syn; - - case UIP_ESTABLISHED: - /* In the ESTABLISHED state, we call upon the application - * to do the actual retransmit after which we jump into - * the code for sending out the packet (the apprexmit - * label). - */ - - uip_flags = UIP_REXMIT; - uip_tcp_callback(dev); - goto apprexmit; - - case UIP_FIN_WAIT_1: - case UIP_CLOSING: - case UIP_LAST_ACK: - /* In all these states we should retransmit a FINACK. */ - - goto tcp_send_finack; - } - } - } - else if ((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED) - { - /* If there was no need for a retransmission, we poll the - * application for new data. - */ - - uip_flags = UIP_POLL; - uip_tcp_callback(dev); - goto appsend; - } - } - goto drop; - } - - /* This is where the input processing starts. */ - - UIP_STAT(++uip_stat.ip.recv); - - /* Start of IP input header processing code. */ - -#ifdef CONFIG_NET_IPv6 - /* Check validity of the IP header. */ - - if ((BUF->vtc & 0xf0) != 0x60) - { - /* IP version and header length. */ - - UIP_STAT(++uip_stat.ip.drop); - UIP_STAT(++uip_stat.ip.vhlerr); - uip_log("ipv6: invalid version."); - goto drop; - } -#else /* CONFIG_NET_IPv6 */ - /* Check validity of the IP header. */ - - if (BUF->vhl != 0x45) - { - /* IP version and header length. */ - - UIP_STAT(++uip_stat.ip.drop); - UIP_STAT(++uip_stat.ip.vhlerr); - uip_log("ip: invalid version or header length."); - goto drop; - } -#endif /* CONFIG_NET_IPv6 */ - - /* Check the size of the packet. If the size reported to us in d_len is - * smaller the size reported in the IP header, we assume that the packet - * has been corrupted in transit. If the size of d_len is larger than the - * size reported in the IP packet header, the packet has been padded and - * we set d_len to the correct value. - */ - - if ((BUF->len[0] << 8) + BUF->len[1] <= dev->d_len) - { - dev->d_len = (BUF->len[0] << 8) + BUF->len[1]; -#ifdef CONFIG_NET_IPv6 - /* The length reported in the IPv6 header is the length of the - * payload that follows the header. However, uIP uses the d_len - * variable for holding the size of the entire packet, including the - * IP header. For IPv4 this is not a problem as the length field in - * the IPv4 header contains the length of the entire packet. But - * for IPv6 we need to add the size of the IPv6 header (40 bytes). - */ - - dev->d_len += 40; -#endif /* CONFIG_NET_IPv6 */ - } - else - { - uip_log("ip: packet shorter than reported in IP header."); - goto drop; - } - -#ifndef CONFIG_NET_IPv6 - /* Check the fragment flag. */ - - if ((BUF->ipoffset[0] & 0x3f) != 0 || BUF->ipoffset[1] != 0) - { -#if UIP_REASSEMBLY - dev->d_len = uip_reass(); - if (dev->d_len == 0) - { - goto drop; - } -#else /* UIP_REASSEMBLY */ - UIP_STAT(++uip_stat.ip.drop); - UIP_STAT(++uip_stat.ip.fragerr); - uip_log("ip: fragment dropped."); - goto drop; -#endif /* UIP_REASSEMBLY */ - } -#endif /* CONFIG_NET_IPv6 */ - - if (uip_ipaddr_cmp(dev->d_ipaddr, all_zeroes_addr)) - { - /* If we are configured to use ping IP address configuration and - * hasn't been assigned an IP address yet, we accept all ICMP - * packets. - */ - -#if UIP_PINGADDRCONF && !CONFIG_NET_IPv6 - if (BUF->proto == UIP_PROTO_ICMP) - { - uip_log("ip: possible ping config packet received."); - goto icmp_input; - } - else - { - uip_log("ip: packet dropped since no address assigned."); - goto drop; - } -#endif /* UIP_PINGADDRCONF */ - } - else - { - /* If IP broadcast support is configured, we check for a broadcast - * UDP packet, which may be destined to us. - */ - -#if UIP_BROADCAST - if (BUF->proto == UIP_PROTO_UDP && uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr) - { - goto udp_input; - } -#endif /* UIP_BROADCAST */ - - /* Check if the packet is destined for our IP address. */ -#ifndef CONFIG_NET_IPv6 - if (!uip_ipaddr_cmp(uip_ip4addr_conv(BUF->destipaddr), dev->d_ipaddr)) - { - UIP_STAT(++uip_stat.ip.drop); - goto drop; - } -#else /* CONFIG_NET_IPv6 */ - /* For IPv6, packet reception is a little trickier as we need to - * make sure that we listen to certain multicast addresses (all - * hosts multicast address, and the solicited-node multicast - * address) as well. However, we will cheat here and accept all - * multicast packets that are sent to the ff02::/16 addresses. - */ - - if (!uip_ipaddr_cmp(BUF->destipaddr, dev->d_ipaddr) && - BUF->destipaddr & HTONL(0xffff0000) != HTONL(0xff020000)) - { - UIP_STAT(++uip_stat.ip.drop); - goto drop; - } -#endif /* CONFIG_NET_IPv6 */ - } - -#ifndef CONFIG_NET_IPv6 - if (uip_ipchksum(dev) != 0xffff) - { - /* Compute and check the IP header checksum. */ - - UIP_STAT(++uip_stat.ip.drop); - UIP_STAT(++uip_stat.ip.chkerr); - uip_log("ip: bad checksum."); - goto drop; - } -#endif /* CONFIG_NET_IPv6 */ - - if (BUF->proto == UIP_PROTO_TCP) - { - /* Check for TCP packet. If so, proceed with TCP input processing. */ - - goto tcp_input; - } - -#ifdef CONFIG_NET_UDP - if (BUF->proto == UIP_PROTO_UDP) - { - uip_udpinput(dev); - return; - } -#endif - -#ifndef CONFIG_NET_IPv6 - /* ICMPv4 processing code follows. */ - - if (BUF->proto != UIP_PROTO_ICMP) - { - /* We only allow ICMP packets from here. */ - - UIP_STAT(++uip_stat.ip.drop); - UIP_STAT(++uip_stat.ip.protoerr); - uip_log("ip: neither tcp nor icmp."); - goto drop; - } - -#if UIP_PINGADDRCONF -icmp_input: -#endif - UIP_STAT(++uip_stat.icmp.recv); - - /* ICMP echo (i.e., ping) processing. This is simple, we only change - * the ICMP type from ECHO to ECHO_REPLY and adjust the ICMP - * checksum before we return the packet. - */ - - if (ICMPBUF->type != ICMP_ECHO) - { - UIP_STAT(++uip_stat.icmp.drop); - UIP_STAT(++uip_stat.icmp.typeerr); - uip_log("icmp: not icmp echo."); - goto drop; - } - - /* If we are configured to use ping IP address assignment, we use - * the destination IP address of this ping packet and assign it to - * ourself. - */ - -#if UIP_PINGADDRCONF - if (dev->d_ipaddr == 0) - { - dev->d_ipaddr = BUF->destipaddr; - } -#endif /* UIP_PINGADDRCONF */ - - ICMPBUF->type = ICMP_ECHO_REPLY; - - if (ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) - { - ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1; - } - else - { - ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8); - } - - /* Swap IP addresses. */ - - uiphdr_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr); - uiphdr_ipaddr_copy(BUF->srcipaddr, &dev->d_ipaddr); - - UIP_STAT(++uip_stat.icmp.sent); - goto send; -#else /* !CONFIG_NET_IPv6 */ - - /* This is IPv6 ICMPv6 processing code. */ - - if (BUF->proto != UIP_PROTO_ICMP6) - { - /* We only allow ICMPv6 packets from here. */ - - UIP_STAT(++uip_stat.ip.drop); - UIP_STAT(++uip_stat.ip.protoerr); - uip_log("ip: neither tcp nor icmp6."); - goto drop; - } - - UIP_STAT(++uip_stat.icmp.recv); - - /* If we get a neighbor solicitation for our address we should send - * a neighbor advertisement message back. - */ - - if (ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION) - { - if (uip_ipaddr_cmp(ICMPBUF->icmp6data, dev->d_ipaddr)) - { - if (ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS) - { - /* Save the sender's address in our neighbor list. */ - - uiphdr_neighbor_add(ICMPBUF->srcipaddr, &(ICMPBUF->options[2])); - } - - /* We should now send a neighbor advertisement back to where the - * neighbor solicication came from. - */ - - ICMPBUF->type = ICMP6_NEIGHBOR_ADVERTISEMENT; - ICMPBUF->flags = ICMP6_FLAG_S; /* Solicited flag. */ - - ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0; - - uiphdr_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr); - uiphdr_ipaddr_copy(ICMPBUF->srcipaddr, dev->d_ipaddr); - ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS; - ICMPBUF->options[1] = 1; /* Options length, 1 = 8 bytes. */ - memcpy(&(ICMPBUF->options[2]), &dev->d_mac, IFHWADDRLEN); - ICMPBUF->icmpchksum = 0; - ICMPBUF->icmpchksum = ~uip_icmp6chksum(dev); - goto send; - } - goto drop; - } - else if (ICMPBUF->type == ICMP6_ECHO) - { - /* ICMP echo (i.e., ping) processing. This is simple, we only - * change the ICMP type from ECHO to ECHO_REPLY and update the - * ICMP checksum before we return the packet. - */ - - ICMPBUF->type = ICMP6_ECHO_REPLY; - - uiphdr_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr); - uiphdr_ipaddr_copy(BUF->srcipaddr, dev->d_ipaddr); - ICMPBUF->icmpchksum = 0; - ICMPBUF->icmpchksum = ~uip_icmp6chksum(dev); - - UIP_STAT(++uip_stat.icmp.sent); - goto send; - } - else - { - UIP_STAT(++uip_stat.icmp.drop); - UIP_STAT(++uip_stat.icmp.typeerr); - uip_log("icmp: unknown ICMP message."); - goto drop; - } -#endif /* !CONFIG_NET_IPv6 */ - - /* TCP input processing. */ - -tcp_input: - - UIP_STAT(++uip_stat.tcp.recv); - - /* Start of TCP input header processing code. */ - - if (uip_tcpchksum(dev) != 0xffff) - { - /* Compute and check the TCP checksum. */ - - UIP_STAT(++uip_stat.tcp.drop); - UIP_STAT(++uip_stat.tcp.chkerr); - uip_log("tcp: bad checksum."); - goto drop; - } - - /* Demultiplex this segment. First check any active connections. */ - - uip_connr = uip_tcpactive(BUF); - if (uip_connr) - { - goto found; - } - - /* If we didn't find and active connection that expected the packet, - * either this packet is an old duplicate, or this is a SYN packet - * destined for a connection in LISTEN. If the SYN flag isn't set, - * it is an old packet and we send a RST. - */ - - if ((BUF->flags & TCP_CTL) != TCP_SYN) - { - goto reset; - } - - tmp16 = BUF->destport; - - /* Next, check listening connections. */ - - if (uip_islistener(tmp16)) - { - goto found_listen; - } - - /* No matching connection found, so we send a RST packet. */ - - UIP_STAT(++uip_stat.tcp.synrst); - -reset: - - /* We do not send resets in response to resets. */ - - if (BUF->flags & TCP_RST) - { - goto drop; - } - - UIP_STAT(++uip_stat.tcp.rst); - - BUF->flags = TCP_RST | TCP_ACK; - dev->d_len = UIP_IPTCPH_LEN; - BUF->tcpoffset = 5 << 4; - - /* Flip the seqno and ackno fields in the TCP header. */ - - seqbyte = BUF->seqno[3]; - BUF->seqno[3] = BUF->ackno[3]; - BUF->ackno[3] = seqbyte; - - seqbyte = BUF->seqno[2]; - BUF->seqno[2] = BUF->ackno[2]; - BUF->ackno[2] = seqbyte; - - seqbyte = BUF->seqno[1]; - BUF->seqno[1] = BUF->ackno[1]; - BUF->ackno[1] = seqbyte; - - seqbyte = BUF->seqno[0]; - BUF->seqno[0] = BUF->ackno[0]; - BUF->ackno[0] = seqbyte; - - /* We also have to increase the sequence number we are - * acknowledging. If the least significant byte overflowed, we need - * to propagate the carry to the other bytes as well. - */ - - if (++(BUF->ackno[3]) == 0) - { - if (++(BUF->ackno[2]) == 0) - { - if (++(BUF->ackno[1]) == 0) - { - ++(BUF->ackno[0]); - } - } - } - - /* Swap port numbers. */ - - tmp16 = BUF->srcport; - BUF->srcport = BUF->destport; - BUF->destport = tmp16; - - /* Swap IP addresses. */ - - uiphdr_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr); - uiphdr_ipaddr_copy(BUF->srcipaddr, dev->d_ipaddr); - - /* And send out the RST packet! */ - - goto tcp_send_noconn; - - /* This label will be jumped to if we matched the incoming packet - * with a connection in LISTEN. In that case, we should create a new - * connection and send a SYNACK in return. - */ - -found_listen: - - /* First allocate a new connection structure and see if there is any - * user application to accept it. - */ - - uip_connr = uip_tcpaccept(BUF); - if (uip_connr) - { - /* The connection structure was successfully allocated. Now see - * there is an application waiting to accept the connection (or at - * least queue it it for acceptance). - */ - - if (uip_accept(uip_connr, tmp16) != OK) - { - /* No, then we have to give the connection back */ - - uip_tcpfree(uip_connr); - uip_connr = NULL; - } - } - - if (!uip_connr) - { - /* Either (1) all available connections are in use, or (2) there is no - * application in place to accept the connection. We drop packet and hope that - * the remote end will retransmit the packet at a time when we - * have more spare connections or someone waiting to accept the connection. - */ - - UIP_STAT(++uip_stat.tcp.syndrop); - uip_log("tcp: found no unused connections."); - goto drop; - } - - uip_add_rcv_nxt(1); - uip_conn = uip_connr; - - /* Parse the TCP MSS option, if present. */ - - if ((BUF->tcpoffset & 0xf0) > 0x50) - { - for (i = 0; i < ((BUF->tcpoffset >> 4) - 5) << 2 ;) - { - opt = dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + i]; - if (opt == TCP_OPT_END) - { - /* End of options. */ - - break; - } - else if (opt == TCP_OPT_NOOP) - { - /* NOP option. */ - - ++i; - } - else if (opt == TCP_OPT_MSS && - dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == TCP_OPT_MSS_LEN) - { - /* An MSS option with the right option length. */ - - tmp16 = ((uint16)dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + i] << 8) | - (uint16)dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + i]; - uip_connr->initialmss = uip_connr->mss = - tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16; - - /* And we are done processing options. */ - - break; - } - else - { - /* All other options have a length field, so that we easily - * can skip past them. - */ - - if (dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == 0) - { - /* If the length field is zero, the options are malformed - * and we don't process them further. - */ - - break; - } - i += dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i]; - } - } - } - - /* Our response will be a SYNACK. */ - -tcp_send_synack: - BUF->flags = TCP_ACK; - -tcp_send_syn: - BUF->flags |= TCP_SYN; - - /* We send out the TCP Maximum Segment Size option with our SYNACK. */ - - BUF->optdata[0] = TCP_OPT_MSS; - BUF->optdata[1] = TCP_OPT_MSS_LEN; - BUF->optdata[2] = (UIP_TCP_MSS) / 256; - BUF->optdata[3] = (UIP_TCP_MSS) & 255; - dev->d_len = UIP_IPTCPH_LEN + TCP_OPT_MSS_LEN; - BUF->tcpoffset = ((UIP_TCPH_LEN + TCP_OPT_MSS_LEN) / 4) << 4; - goto tcp_send; - - /* This label will be jumped to if we found an active connection. */ - -found: - - uip_conn = uip_connr; - uip_flags = 0; - - /* We do a very naive form of TCP reset processing; we just accept - * any RST and kill our connection. We should in fact check if the - * sequence number of this reset is wihtin our advertised window - * before we accept the reset. - */ - - if (BUF->flags & TCP_RST) - { - uip_connr->tcpstateflags = UIP_CLOSED; - vdbg("TCP state: UIP_CLOSED\n"); - uip_log("tcp: got reset, aborting connection."); - - uip_flags = UIP_ABORT; - uip_tcp_callback(dev); - goto drop; - } - - /* Calculated the length of the data, if the application has sent - * any data to us. - */ - - len = (BUF->tcpoffset >> 4) << 2; - - /* d_len will contain the length of the actual TCP data. This is - * calculated by subtracing the length of the TCP header (in - * len) and the length of the IP header (20 bytes). - */ - - dev->d_len -= (len + UIP_IPH_LEN); - - /* First, check if the sequence number of the incoming packet is - * what we're expecting next. If not, we send out an ACK with the - * correct numbers in. - */ - - if (!(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) && - ((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)))) - { - if ((dev->d_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0)) && - (BUF->seqno[0] != uip_connr->rcv_nxt[0] || - BUF->seqno[1] != uip_connr->rcv_nxt[1] || - BUF->seqno[2] != uip_connr->rcv_nxt[2] || - BUF->seqno[3] != uip_connr->rcv_nxt[3])) - { - goto tcp_send_ack; - } - } - - /* Next, check if the incoming segment acknowledges any outstanding - * data. If so, we update the sequence number, reset the length of - * the outstanding data, calculate RTT estimations, and reset the - * retransmission timer. - */ - - if ((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) - { - uip_add32(uip_connr->snd_nxt, uip_connr->len); - - if (BUF->ackno[0] == uip_acc32[0] && - BUF->ackno[1] == uip_acc32[1] && - BUF->ackno[2] == uip_acc32[2] && - BUF->ackno[3] == uip_acc32[3]) - { - /* Update sequence number. */ - - uip_connr->snd_nxt[0] = uip_acc32[0]; - uip_connr->snd_nxt[1] = uip_acc32[1]; - uip_connr->snd_nxt[2] = uip_acc32[2]; - uip_connr->snd_nxt[3] = uip_acc32[3]; - - /* Do RTT estimation, unless we have done retransmissions. */ - - if (uip_connr->nrtx == 0) - { - signed char m; - m = uip_connr->rto - uip_connr->timer; - - /* This is taken directly from VJs original code in his paper */ - - m = m - (uip_connr->sa >> 3); - uip_connr->sa += m; - if (m < 0) - { - m = -m; - } - - m = m - (uip_connr->sv >> 2); - uip_connr->sv += m; - uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv; - } - - /* Set the acknowledged flag. */ - - uip_flags = UIP_ACKDATA; - - /* Reset the retransmission timer. */ - - uip_connr->timer = uip_connr->rto; - - /* Reset length of outstanding data. */ - - uip_connr->len = 0; - } - } - - /* Do different things depending on in what state the connection is. */ - - switch(uip_connr->tcpstateflags & UIP_TS_MASK) - { - /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not - * implemented, since we force the application to close when the - * peer sends a FIN (hence the application goes directly from - * ESTABLISHED to LAST_ACK). - */ - - case UIP_SYN_RCVD: - /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and - * we are waiting for an ACK that acknowledges the data we sent - * out the last time. Therefore, we want to have the UIP_ACKDATA - * flag set. If so, we enter the ESTABLISHED state. - */ - - if (uip_flags & UIP_ACKDATA) - { - uip_connr->tcpstateflags = UIP_ESTABLISHED; - uip_connr->len = 0; - vdbg("TCP state: UIP_ESTABLISHED\n"); - - uip_flags = UIP_CONNECTED; - - if (dev->d_len > 0) - { - uip_flags |= UIP_NEWDATA; - uip_add_rcv_nxt(dev->d_len); - } - - dev->d_sndlen = 0; - uip_tcp_callback(dev); - goto appsend; - } - goto drop; - - case UIP_SYN_SENT: - /* In SYN_SENT, we wait for a SYNACK that is sent in response to - * our SYN. The rcv_nxt is set to sequence number in the SYNACK - * plus one, and we send an ACK. We move into the ESTABLISHED - * state. - */ - - if ((uip_flags & UIP_ACKDATA) && - (BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)) - { - /* Parse the TCP MSS option, if present. */ - - if ((BUF->tcpoffset & 0xf0) > 0x50) - { - for (i = 0; i < ((BUF->tcpoffset >> 4) - 5) << 2 ;) - { - opt = dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + i]; - if (opt == TCP_OPT_END) - { - /* End of options. */ - - break; - } - else if (opt == TCP_OPT_NOOP) - { - /* NOP option. */ - - ++i; - } - else if (opt == TCP_OPT_MSS && - dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == TCP_OPT_MSS_LEN) - { - /* An MSS option with the right option length. */ - - tmp16 = - (dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + i] << 8) | - dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + i]; - uip_connr->initialmss = - uip_connr->mss = - tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16; - - /* And we are done processing options. */ - - break; - } - else - { - /* All other options have a length field, so that we - * easily can skip past them. - */ - - if (dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == 0) - { - /* If the length field is zero, the options are - * malformed and we don't process them further. - */ - - break; - } - i += dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i]; - } - } - } - - uip_connr->tcpstateflags = UIP_ESTABLISHED; - uip_connr->rcv_nxt[0] = BUF->seqno[0]; - uip_connr->rcv_nxt[1] = BUF->seqno[1]; - uip_connr->rcv_nxt[2] = BUF->seqno[2]; - uip_connr->rcv_nxt[3] = BUF->seqno[3]; - vdbg("TCP state: UIP_ESTABLISHED\n"); - - uip_add_rcv_nxt(1); - uip_flags = UIP_CONNECTED | UIP_NEWDATA; - uip_connr->len = 0; - dev->d_len = 0; - dev->d_sndlen = 0; - uip_tcp_callback(dev); - goto appsend; - } - - /* Inform the application that the connection failed */ - - uip_flags = UIP_ABORT; - uip_tcp_callback(dev); - - /* The connection is closed after we send the RST */ - - uip_conn->tcpstateflags = UIP_CLOSED; - vdbg("TCP state: UIP_CLOSED\n"); - goto reset; - - case UIP_ESTABLISHED: - /* In the ESTABLISHED state, we call upon the application to feed - * data into the d_buf. If the UIP_ACKDATA flag is set, the - * application should put new data into the buffer, otherwise we are - * retransmitting an old segment, and the application should put that - * data into the buffer. - * - * If the incoming packet is a FIN, we should close the connection on - * this side as well, and we send out a FIN and enter the LAST_ACK - * state. We require that there is no outstanding data; otherwise the - * sequence numbers will be screwed up. - */ - - if (BUF->flags & TCP_FIN && !(uip_connr->tcpstateflags & UIP_STOPPED)) - { - if (uip_outstanding(uip_connr)) - { - goto drop; - } - - uip_add_rcv_nxt(dev->d_len + 1); - uip_flags |= UIP_CLOSE; - - if (dev->d_len > 0) - { - uip_flags |= UIP_NEWDATA; - } - - uip_tcp_callback(dev); - - uip_connr->tcpstateflags = UIP_LAST_ACK; - uip_connr->len = 1; - uip_connr->nrtx = 0; - vdbg("TCP state: UIP_LAST_ACK\n"); - -tcp_send_finack: - - BUF->flags = TCP_FIN | TCP_ACK; - goto tcp_send_nodata; - } - - /* Check the URG flag. If this is set, the segment carries urgent - data that we must pass to the application. */ - if ((BUF->flags & TCP_URG) != 0) - { -#if UIP_URGDATA > 0 - uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1]; - if (uip_urglen > dev->d_len) - { - /* There is more urgent data in the next segment to come. */ - - uip_urglen = dev->d_len; - } - - uip_add_rcv_nxt(uip_urglen); - dev->d_len -= uip_urglen; - uip_urgdata = dev->d_appdata; - dev->d_appdata += uip_urglen; - } - else - { - uip_urglen = 0; -#else /* UIP_URGDATA > 0 */ - dev->d_appdata = - ((uint8*)dev->d_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]); - dev->d_len -= - (BUF->urgp[0] << 8) | BUF->urgp[1]; -#endif /* UIP_URGDATA > 0 */ - } - - /* If d_len > 0 we have TCP data in the packet, and we flag this - * by setting the UIP_NEWDATA flag and update the sequence number - * we acknowledge. If the application has stopped the dataflow - * using uip_stop(), we must not accept any data packets from the - * remote host. - */ - - if (dev->d_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) - { - uip_flags |= UIP_NEWDATA; - uip_add_rcv_nxt(dev->d_len); - } - - /* Check if the available buffer space advertised by the other end - * is smaller than the initial MSS for this connection. If so, we - * set the current MSS to the window size to ensure that the - * application does not send more data than the other end can - * handle. - * - * If the remote host advertises a zero window, we set the MSS to - * the initial MSS so that the application will send an entire MSS - * of data. This data will not be acknowledged by the receiver, - * and the application will retransmit it. This is called the - * "persistent timer" and uses the retransmission mechanim. - */ - - tmp16 = ((uint16)BUF->wnd[0] << 8) + (uint16)BUF->wnd[1]; - if (tmp16 > uip_connr->initialmss || tmp16 == 0) - { - tmp16 = uip_connr->initialmss; - } - uip_connr->mss = tmp16; - - /* If this packet constitutes an ACK for outstanding data (flagged - * by the UIP_ACKDATA flag, we should call the application since it - * might want to send more data. If the incoming packet had data - * from the peer (as flagged by the UIP_NEWDATA flag), the - * application must also be notified. - * - * When the application is called, the d_len field - * contains the length of the incoming data. The application can - * access the incoming data through the global pointer - * d_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN - * bytes into the d_buf array. - * - * If the application wishes to send any data, this data should be - * put into the d_appdata and the length of the data should be - * put into d_len. If the application don't have any data to - * send, d_len must be set to 0. - */ - - if (uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) - { - dev->d_sndlen = 0; - uip_tcp_callback(dev); - -appsend: - - if (uip_flags & UIP_ABORT) - { - dev->d_sndlen = 0; - uip_connr->tcpstateflags = UIP_CLOSED; - vdbg("TCP state: UIP_CLOSED\n"); - - BUF->flags = TCP_RST | TCP_ACK; - goto tcp_send_nodata; - } - - if (uip_flags & UIP_CLOSE) - { - uip_connr->tcpstateflags = UIP_FIN_WAIT_1; - uip_connr->len = 1; - uip_connr->nrtx = 0; - vdbg("TCP state: UIP_FIN_WAIT_1\n"); - - BUF->flags = TCP_FIN | TCP_ACK; - dev->d_sndlen = 0; - goto tcp_send_nodata; - } - - /* If d_sndlen > 0, the application has data to be sent. */ - - if (dev->d_sndlen > 0) - { - /* If the connection has acknowledged data, the contents of - * the ->len variable should be discarded. - */ - - if ((uip_flags & UIP_ACKDATA) != 0) - { - uip_connr->len = 0; - } - - /* If the ->len variable is non-zero the connection has - * already data in transit and cannot send anymore right - * now. - */ - - if (uip_connr->len == 0) - { - /* The application cannot send more than what is - * allowed by the mss (the minumum of the MSS and the - * available window). - */ - - if (dev->d_sndlen > uip_connr->mss) - { - dev->d_sndlen = uip_connr->mss; - } - - /* Remember how much data we send out now so that we - * know when everything has been acknowledged. - */ - - uip_connr->len = dev->d_sndlen; - } - else - { - /* If the application already had unacknowledged data, - * we make sure that the application does not send - * (i.e., retransmit) out more than it previously sent - * out. - */ - - dev->d_sndlen = uip_connr->len; - } - } - uip_connr->nrtx = 0; -apprexmit: - dev->d_appdata = dev->d_snddata; - - /* If the application has data to be sent, or if the incoming - * packet had new data in it, we must send out a packet. - */ - - if (dev->d_sndlen > 0 && uip_connr->len > 0) - { - /* Add the length of the IP and TCP headers. */ - - dev->d_len = uip_connr->len + UIP_TCPIP_HLEN; - - /* We always set the ACK flag in response packets. */ - - BUF->flags = TCP_ACK | TCP_PSH; - - /* Send the packet. */ - - goto tcp_send_noopts; - } - - /* If there is no data to send, just send out a pure ACK if - * there is newdata. - */ - - if (uip_flags & UIP_NEWDATA) - { - dev->d_len = UIP_TCPIP_HLEN; - BUF->flags = TCP_ACK; - goto tcp_send_noopts; - } - } - goto drop; - - case UIP_LAST_ACK: - /* We can close this connection if the peer has acknowledged our - * FIN. This is indicated by the UIP_ACKDATA flag. - */ - - if (uip_flags & UIP_ACKDATA) - { - uip_connr->tcpstateflags = UIP_CLOSED; - vdbg("TCP state: UIP_CLOSED\n"); - - uip_flags = UIP_CLOSE; - uip_tcp_callback(dev); - } - break; - - case UIP_FIN_WAIT_1: - /* The application has closed the connection, but the remote host - * hasn't closed its end yet. Thus we do nothing but wait for a - * FIN from the other side. - */ - - if (dev->d_len > 0) - { - uip_add_rcv_nxt(dev->d_len); - } - if (BUF->flags & TCP_FIN) - { - if (uip_flags & UIP_ACKDATA) - { - uip_connr->tcpstateflags = UIP_TIME_WAIT; - uip_connr->timer = 0; - uip_connr->len = 0; - vdbg("TCP state: UIP_TIME_WAIT\n"); - } - else - { - uip_connr->tcpstateflags = UIP_CLOSING; - vdbg("TCP state: UIP_CLOSING\n"); - } - - uip_add_rcv_nxt(1); - uip_flags = UIP_CLOSE; - uip_tcp_callback(dev); - goto tcp_send_ack; - } - else if (uip_flags & UIP_ACKDATA) - { - uip_connr->tcpstateflags = UIP_FIN_WAIT_2; - uip_connr->len = 0; - vdbg("TCP state: UIP_FIN_WAIT_2\n"); - goto drop; - } - - if (dev->d_len > 0) - { - goto tcp_send_ack; - } - goto drop; - - case UIP_FIN_WAIT_2: - if (dev->d_len > 0) - { - uip_add_rcv_nxt(dev->d_len); - } - - if (BUF->flags & TCP_FIN) - { - uip_connr->tcpstateflags = UIP_TIME_WAIT; - uip_connr->timer = 0; - vdbg("TCP state: UIP_TIME_WAIT\n"); - - uip_add_rcv_nxt(1); - uip_flags = UIP_CLOSE; - uip_tcp_callback(dev); - goto tcp_send_ack; - } - - if (dev->d_len > 0) - { - goto tcp_send_ack; - } - goto drop; - - case UIP_TIME_WAIT: - goto tcp_send_ack; - - case UIP_CLOSING: - if (uip_flags & UIP_ACKDATA) - { - uip_connr->tcpstateflags = UIP_TIME_WAIT; - uip_connr->timer = 0; - vdbg("TCP state: UIP_TIME_WAIT\n"); - } - } - goto drop; - - /* We jump here when we are ready to send the packet, and just want - * to set the appropriate TCP sequence numbers in the TCP header. - */ - -tcp_send_ack: - - BUF->flags = TCP_ACK; - -tcp_send_nodata: - - dev->d_len = UIP_IPTCPH_LEN; - -tcp_send_noopts: - - BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4; - -tcp_send: - - /* We're done with the input processing. We are now ready to send a - * reply. Our job is to fill in all the fields of the TCP and IP - * headers before calculating the checksum and finally send the - * packet. - */ - - BUF->ackno[0] = uip_connr->rcv_nxt[0]; - BUF->ackno[1] = uip_connr->rcv_nxt[1]; - BUF->ackno[2] = uip_connr->rcv_nxt[2]; - BUF->ackno[3] = uip_connr->rcv_nxt[3]; - - BUF->seqno[0] = uip_connr->snd_nxt[0]; - BUF->seqno[1] = uip_connr->snd_nxt[1]; - BUF->seqno[2] = uip_connr->snd_nxt[2]; - BUF->seqno[3] = uip_connr->snd_nxt[3]; - - BUF->proto = UIP_PROTO_TCP; - - BUF->srcport = uip_connr->lport; - BUF->destport = uip_connr->rport; - - uiphdr_ipaddr_copy(BUF->srcipaddr, &dev->d_ipaddr); - uiphdr_ipaddr_copy(BUF->destipaddr, &uip_connr->ripaddr); - - if (uip_connr->tcpstateflags & UIP_STOPPED) - { - /* If the connection has issued uip_stop(), we advertise a zero - * window so that the remote host will stop sending data. - */ - - BUF->wnd[0] = BUF->wnd[1] = 0; - } - else - { - BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8); - BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff); - } - -tcp_send_noconn: - - BUF->ttl = UIP_TTL; -#ifdef CONFIG_NET_IPv6 - /* For IPv6, the IP length field does not include the IPv6 IP header - * length. - */ - - BUF->len[0] = ((dev->d_len - UIP_IPH_LEN) >> 8); - BUF->len[1] = ((dev->d_len - UIP_IPH_LEN) & 0xff); -#else /* CONFIG_NET_IPv6 */ - BUF->len[0] = (dev->d_len >> 8); - BUF->len[1] = (dev->d_len & 0xff); -#endif /* CONFIG_NET_IPv6 */ - - BUF->urgp[0] = BUF->urgp[1] = 0; - - /* Calculate TCP checksum. */ - - BUF->tcpchksum = 0; - BUF->tcpchksum = ~(uip_tcpchksum(dev)); - -#ifdef CONFIG_NET_IPv6 - BUF->vtc = 0x60; - BUF->tcflow = 0x00; - BUF->flow = 0x00; -#else /* CONFIG_NET_IPv6 */ - BUF->vhl = 0x45; - BUF->tos = 0; - BUF->ipoffset[0] = 0; - BUF->ipoffset[1] = 0; - ++g_ipid; - BUF->ipid[0] = g_ipid >> 8; - BUF->ipid[1] = g_ipid & 0xff; - - /* Calculate IP checksum. */ - - BUF->ipchksum = 0; - BUF->ipchksum = ~(uip_ipchksum(dev)); -#endif /* CONFIG_NET_IPv6 */ - - UIP_STAT(++uip_stat.tcp.sent); - -send: - vdbg("Sending packet length %d (%d)\n", - dev->d_len, (BUF->len[0] << 8) | BUF->len[1]); - - UIP_STAT(++uip_stat.ip.sent); - - /* Return and let the caller do the actual transmission. */ - - uip_flags = 0; - return; - -drop: - dev->d_len = 0; - uip_flags = 0; - return; -} -#endif /* CONFIG_NET */ - -- cgit v1.2.3