diff --git a/fs/fs_open.c b/fs/fs_open.c
index 094710d3127187bf99618991c15a7745e58a46eb..71fc8d0c42e8adca927e172089d7584afde3e083 100644
--- a/fs/fs_open.c
+++ b/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/include/net/uip/uip-arch.h b/include/net/uip/uip-arch.h
index 8f1d6b41fe86cbbc41f56bca096cfc909856b3e8..1d4337839419176ac320de489993a8a8097dd224 100644
--- a/include/net/uip/uip-arch.h
+++ b/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/include/net/uip/uip.h b/include/net/uip/uip.h
index 283891edb497afe496981d644bfc03d03784e4dd..ed8d85bedafba521191b47577eed476973fdd48f 100644
--- a/include/net/uip/uip.h
+++ b/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/net/uip/Make.defs b/net/uip/Make.defs
index d150e24fefcd6536469a0fb8fb6e2257ea79f977..8a232ffbf127160de261306a3e8889c224eb2b94 100644
--- a/net/uip/Make.defs
+++ b/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/net/uip/uip-chksum.c b/net/uip/uip-chksum.c
index ebf814e8b271c68fe3f57508035d350b89d31ca7..c8c173b9585ebc1fea1e4e9e2add2fa9f0596ca0 100644
--- a/net/uip/uip-chksum.c
+++ b/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/net/uip/uip-icmpinput.c b/net/uip/uip-icmpinput.c
new file mode 100644
index 0000000000000000000000000000000000000000..c3d30dd4e1bd3a14a46e6359c4d19555e036a051
--- /dev/null
+++ b/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 <spudmonkey@racsa.co.cr>
+ *
+ * Adapted for NuttX from logic in uIP which also has a BSD-like license:
+ *
+ * Original author Adam Dunkels <adam@dunkels.com>
+ * 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 <nuttx/config.h>
+#ifdef CONFIG_NET
+
+#include <sys/types.h>
+#include <debug.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <net/uip/uip-arch.h>
+
+#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/net/uip/uip-initialize.c b/net/uip/uip-initialize.c
index dabcf64cc5c7b976d6c952690959db670472478c..00a01ef6aa615830489c9104f802cb1749a89548 100644
--- a/net/uip/uip-initialize.c
+++ b/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/net/uip/uip-input.c b/net/uip/uip-input.c
new file mode 100644
index 0000000000000000000000000000000000000000..de82236400688719ef8df1f89391dbbc834c559b
--- /dev/null
+++ b/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 <spudmonkey@racsa.co.cr>
+ *
+ * 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 <adam@dunkels.com>
+ * 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 <nuttx/config.h>
+#ifdef CONFIG_NET
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+
+#include <debug.h>
+#include <string.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <net/uip/uip-arch.h>
+
+#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/net/uip/uip-internal.h b/net/uip/uip-internal.h
index c8d1e10c41592fa02b939ac62a2964990e01e5eb..d1f141a303b67a79928e24480b06cb148705edc7 100644
--- a/net/uip/uip-internal.h
+++ b/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/net/uip/uip-poll.c b/net/uip/uip-poll.c
index 19dc16a5af3aeec3f46e08e4207a99170c65ff16..0ac8fac976aa955cd91292526306e8302d49b18c 100644
--- a/net/uip/uip-poll.c
+++ b/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/net/uip/uip-setipid.c b/net/uip/uip-setipid.c
new file mode 100644
index 0000000000000000000000000000000000000000..71467b0f8d39cac5468232e23435c479694ca00f
--- /dev/null
+++ b/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 <spudmonkey@racsa.co.cr>
+ *
+ *
+ * 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 <nuttx/config.h>
+#ifdef CONFIG_NET
+
+#include <sys/types.h>
+#include <debug.h>
+
+#include <net/uip/uip.h>
+
+#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/net/uip/uip-split.c b/net/uip/uip-split.c
index 8488bd3d1642caa53783cd2368c0216e25342761..8d75487d29b7e9e1ac83a973011588de8dc5f1d5 100644
--- a/net/uip/uip-split.c
+++ b/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/net/uip/uip-tcpappsend.c b/net/uip/uip-tcpappsend.c
new file mode 100644
index 0000000000000000000000000000000000000000..c0bbe8b48dafcc6e179174e218e9bcf185807df7
--- /dev/null
+++ b/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 <spudmonkey@racsa.co.cr>
+ *
+ * Adapted for NuttX from logic in uIP which also has a BSD-like license:
+ *
+ * Original author Adam Dunkels <adam@dunkels.com>
+ * 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 <nuttx/config.h>
+#ifdef CONFIG_NET
+
+#include <sys/types.h>
+#include <debug.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <net/uip/uip-arch.h>
+
+#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/net/uip/uip-tcpcallback.c b/net/uip/uip-tcpcallback.c
new file mode 100644
index 0000000000000000000000000000000000000000..ad182271240b03f8358c13bccf186bf09e98daa4
--- /dev/null
+++ b/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 <spudmonkey@racsa.co.cr>
+ *
+ *
+ * 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 <nuttx/config.h>
+#ifdef CONFIG_NET
+
+#include <sys/types.h>
+#include <debug.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <net/uip/uip-arch.h>
+
+#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/net/uip/uip-tcpinput.c b/net/uip/uip-tcpinput.c
new file mode 100644
index 0000000000000000000000000000000000000000..b8a225dbcef846ab80f69a37e0ebefd9c8e5542b
--- /dev/null
+++ b/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 <spudmonkey@racsa.co.cr>
+ *
+ * Adapted for NuttX from logic in uIP which also has a BSD-like license:
+ *
+ * Original author Adam Dunkels <adam@dunkels.com>
+ * 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 <nuttx/config.h>
+#ifdef CONFIG_NET
+
+#include <sys/types.h>
+#include <debug.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <net/uip/uip-arch.h>
+
+#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/net/uip/uip-tcppoll.c b/net/uip/uip-tcppoll.c
new file mode 100644
index 0000000000000000000000000000000000000000..625b919317f2444c756315503e41b9dc3c239d1b
--- /dev/null
+++ b/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 <spudmonkey@racsa.co.cr>
+ *
+ * Adapted for NuttX from logic in uIP which also has a BSD-like license:
+ *
+ * Original author Adam Dunkels <adam@dunkels.com>
+ * 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 <nuttx/config.h>
+#ifdef CONFIG_NET
+
+#include <sys/types.h>
+#include <debug.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <net/uip/uip-arch.h>
+
+#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/net/uip/uip-tcpsend.c b/net/uip/uip-tcpsend.c
new file mode 100644
index 0000000000000000000000000000000000000000..9c367159dd6ce068c58de90f4077e68511081702
--- /dev/null
+++ b/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 <spudmonkey@racsa.co.cr>
+ *
+ * Adapted for NuttX from logic in uIP which also has a BSD-like license:
+ *
+ * Original author Adam Dunkels <adam@dunkels.com>
+ * 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 <nuttx/config.h>
+#ifdef CONFIG_NET
+
+#include <sys/types.h>
+#include <debug.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <net/uip/uip-arch.h>
+
+#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/net/uip/uip-tcptimer.c b/net/uip/uip-tcptimer.c
new file mode 100644
index 0000000000000000000000000000000000000000..5b248f358bf0d7d18801d84a1730d2b592f59ea8
--- /dev/null
+++ b/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 <spudmonkey@racsa.co.cr>
+ *
+ * Adapted for NuttX from logic in uIP which also has a BSD-like license:
+ *
+ * Original author Adam Dunkels <adam@dunkels.com>
+ * 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 <nuttx/config.h>
+#ifdef CONFIG_NET
+
+#include <sys/types.h>
+#include <debug.h>
+
+#include <net/uip/uipopt.h>
+#include <net/uip/uip.h>
+#include <net/uip/uip-arch.h>
+
+#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/net/uip/uip-udpsend.c b/net/uip/uip-udpsend.c
index 207c0ea35d36db7b16b830a6d5c8e90ce503cc20..7a2a0547cb11e863cfbf715f1d9ac9e258b5807e 100644
--- a/net/uip/uip-udpsend.c
+++ b/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 <spudmonkey@racsa.co.cr>
@@ -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/net/uip/uip.c b/net/uip/uip.c
deleted file mode 100644
index 7c9a997b6eaf3d083697611917cae01e7e2afda2..0000000000000000000000000000000000000000
--- a/net/uip/uip.c
+++ /dev/null
@@ -1,1767 +0,0 @@
-/****************************************************************************
- * uip.c
- * The uIP TCP/IP stack code.
- * author Adam Dunkels <adam@dunkels.com>
- *
- * 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 <nuttx/config.h>
-#ifdef CONFIG_NET
-
-#include <sys/types.h>
-#include <sys/ioctl.h>
-
-#include <debug.h>
-#include <string.h>
-
-#include <net/uip/uipopt.h>
-#include <net/uip/uip.h>
-#include <net/uip/uip-arch.h>
-
-#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 */
-