diff options
| author | Yuval Adam <yuv.adm@gmail.com> | 2014-08-08 14:42:07 +0300 |
|---|---|---|
| committer | Yuval Adam <yuv.adm@gmail.com> | 2014-08-08 14:42:07 +0300 |
| commit | a6163888f3c56123b1db313743c6147ba498732c (patch) | |
| tree | ff7d15d991d1d09ba6cbc0cec80924f57445bfdd /third_party/FreeRTOS/Demo/Common/ethernet/FreeRTOS-uIP/uip.c | |
| parent | c3e4c9a25c2910d2d66d52215b3406b13d5b23d5 (diff) | |
Add third_party libs
Diffstat (limited to 'third_party/FreeRTOS/Demo/Common/ethernet/FreeRTOS-uIP/uip.c')
| -rw-r--r-- | third_party/FreeRTOS/Demo/Common/ethernet/FreeRTOS-uIP/uip.c | 2233 |
1 files changed, 2233 insertions, 0 deletions
diff --git a/third_party/FreeRTOS/Demo/Common/ethernet/FreeRTOS-uIP/uip.c b/third_party/FreeRTOS/Demo/Common/ethernet/FreeRTOS-uIP/uip.c new file mode 100644 index 0000000..1c07f35 --- /dev/null +++ b/third_party/FreeRTOS/Demo/Common/ethernet/FreeRTOS-uIP/uip.c @@ -0,0 +1,2233 @@ +#define DEBUG_PRINTF( ... ) /*printf(__VA_ARGS__)*/
+
+/**
+ * \defgroup uip The uIP TCP/IP stack
+ * @{
+ *
+ * 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.
+ */
+
+/**
+ * \file
+ * The uIP TCP/IP stack code.
+ * \author Adam Dunkels <adam@dunkels.com>
+ */
+
+/*
+ * Copyright (c) 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.
+ *
+ * This file is part of the uIP TCP/IP stack.
+ *
+ * $Id: uip.c,v 1.65 2006/06/11 21:46:39 adam Exp $
+ *
+ */
+
+/*
+ * 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_process()
+ * 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 uip_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 uip_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 uip_buf. The uip_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.
+*/
+#include "uip.h"
+#include "uipopt.h"
+#include "uip_arch.h"
+#include "uip_arp.h"
+#include "FreeRTOS.h"
+
+#if UIP_CONF_IPV6
+ #include "uip-neighbor.h"
+#endif /* UIP_CONF_IPV6 */
+
+#include <string.h>
+
+/*---------------------------------------------------------------------------*/
+
+/* Variable definitions. */
+
+/* The IP address of this host. If it is defined to be fixed (by
+ setting UIP_FIXEDADDR to 1 in uipopt.h), the address is set
+ here. Otherwise, the address */
+#if UIP_FIXEDADDR > 0
+const uip_ipaddr_t uip_hostaddr = { HTONS( (UIP_IPADDR0 << 8) | UIP_IPADDR1 ), HTONS( (UIP_IPADDR2 << 8) | UIP_IPADDR3 ) };
+const uip_ipaddr_t uip_draddr = { HTONS( (UIP_DRIPADDR0 << 8) | UIP_DRIPADDR1 ), HTONS( (UIP_DRIPADDR2 << 8) | UIP_DRIPADDR3 ) };
+const uip_ipaddr_t uip_netmask = { HTONS( (UIP_NETMASK0 << 8) | UIP_NETMASK1 ), HTONS( (UIP_NETMASK2 << 8) | UIP_NETMASK3 ) };
+#else
+uip_ipaddr_t uip_hostaddr, uip_draddr, uip_netmask;
+#endif /* UIP_FIXEDADDR */
+
+static const uip_ipaddr_t all_ones_addr =
+#if UIP_CONF_IPV6
+{ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff };
+#else /* UIP_CONF_IPV6 */
+{
+ 0xffff, 0xffff
+};
+#endif /* UIP_CONF_IPV6 */
+static const uip_ipaddr_t all_zeroes_addr =
+#if UIP_CONF_IPV6
+{ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 };
+#else /* UIP_CONF_IPV6 */
+{
+ 0x0000, 0x0000
+};
+#endif /* UIP_CONF_IPV6 */
+
+#if UIP_FIXEDETHADDR
+const struct uip_eth_addr uip_ethaddr = { { UIP_ETHADDR0, UIP_ETHADDR1, UIP_ETHADDR2, UIP_ETHADDR3, UIP_ETHADDR4, UIP_ETHADDR5 } };
+#else
+struct uip_eth_addr uip_ethaddr = { { 0, 0, 0, 0, 0, 0 } };
+#endif
+#ifndef UIP_CONF_EXTERNAL_BUFFER
+ #ifdef __ICCARM__
+ #pragma data_alignment = 4
+u8_t uip_buf[UIP_BUFSIZE + 2]; /* The packet buffer that contains incoming packets. */
+ #else
+u8_t uip_buf[UIP_BUFSIZE + 2] ALIGN_STRUCT_END; /* The packet buffer that contains incoming packets. */
+ #endif
+#endif /* UIP_CONF_EXTERNAL_BUFFER */
+
+void *uip_appdata; /* The uip_appdata pointer points to
+ application data. */
+void *uip_sappdata; /* The uip_appdata pointer points to
+ the application data which is to
+ be sent. */
+#if UIP_URGDATA > 0
+void *uip_urgdata; /* The uip_urgdata pointer points to
+ urgent data (out-of-band data), if
+ present. */
+u16_t uip_urglen, uip_surglen;
+#endif /* UIP_URGDATA > 0 */
+
+u16_t uip_len, uip_slen;
+
+/* The uip_len is either 8 or 16 bits,
+ depending on the maximum packet
+ size. */
+u8_t uip_flags; /* The uip_flags variable is used for
+ communication between the TCP/IP stack
+ and the application program. */
+struct uip_conn *uip_conn; /* uip_conn always points to the current
+ connection. */
+
+struct uip_conn uip_conns[UIP_CONNS];
+
+/* The uip_conns array holds all TCP
+ connections. */
+u16_t uip_listenports[UIP_LISTENPORTS];
+
+/* The uip_listenports list all currently
+ listning ports. */
+#if UIP_UDP
+struct uip_udp_conn *uip_udp_conn;
+struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
+#endif /* UIP_UDP */
+
+static u16_t ipid; /* Ths ipid variable is an increasing
+ number that is used for the IP ID
+ field. */
+
+void uip_setipid( u16_t id )
+{
+ ipid = id;
+}
+
+static u8_t iss[4]; /* The iss variable is used for the TCP
+ initial sequence number. */
+
+#if UIP_ACTIVE_OPEN
+static u16_t lastport; /* Keeps track of the last port used for
+ a new connection. */
+#endif /* UIP_ACTIVE_OPEN */
+
+/* Temporary variables. */
+u8_t uip_acc32[4];
+static u8_t c, opt;
+static u16_t tmp16;
+
+/* Structures and 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 * ) &uip_buf[UIP_LLH_LEN] )
+#define FBUF ( ( struct uip_tcpip_hdr * ) &uip_reassbuf[0] )
+#define ICMPBUF ( ( struct uip_icmpip_hdr * ) &uip_buf[UIP_LLH_LEN] )
+#define UDPBUF ( ( struct uip_udpip_hdr * ) &uip_buf[UIP_LLH_LEN] )
+#if UIP_STATISTICS == 1
+struct uip_stats uip_stat;
+ #define UIP_STAT( s ) s
+#else
+ #define UIP_STAT( s )
+#endif /* UIP_STATISTICS == 1 */
+
+#if UIP_LOGGING == 1
+ #include <stdio.h>
+void uip_log( char *msg );
+ #define UIP_LOG( m ) uip_log( m )
+#else
+ #define UIP_LOG( m )
+#endif /* UIP_LOGGING == 1 */
+
+#if !UIP_ARCH_ADD32
+void uip_add32( u8_t *op32, u16_t 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) )
+ {
+ ++uip_acc32[1];
+ if( uip_acc32[1] == 0 )
+ {
+ ++uip_acc32[0];
+ }
+ }
+
+ if( uip_acc32[3] < (op16 & 0xff) )
+ {
+ ++uip_acc32[2];
+ if( uip_acc32[2] == 0 )
+ {
+ ++uip_acc32[1];
+ if( uip_acc32[1] == 0 )
+ {
+ ++uip_acc32[0];
+ }
+ }
+ }
+}
+
+#endif /* UIP_ARCH_ADD32 */
+
+#if !UIP_ARCH_CHKSUM
+
+/*---------------------------------------------------------------------------*/
+static u16_t chksum( u16_t sum, const u8_t *data, u16_t len )
+{
+ u16_t t;
+ const u8_t *dataptr;
+ const u8_t *last_byte;
+
+ dataptr = data;
+ last_byte = data + len - 1;
+
+ while( dataptr < last_byte )
+ { /* At least two more bytes */
+ t = ( dataptr[0] << 8 ) + dataptr[1];
+ sum += t;
+ if( sum < t )
+ {
+ sum++; /* carry */
+ }
+
+ dataptr += 2;
+ }
+
+ if( dataptr == last_byte )
+ {
+ t = ( dataptr[0] << 8 ) + 0;
+ sum += t;
+ if( sum < t )
+ {
+ sum++; /* carry */
+ }
+ }
+
+ /* Return sum in host byte order. */
+ return sum;
+}
+
+/*---------------------------------------------------------------------------*/
+u16_t uip_chksum( u16_t *data, u16_t len )
+{
+ return htons( chksum(0, ( u8_t * ) data, len) );
+}
+
+/*---------------------------------------------------------------------------*/
+ #ifndef UIP_ARCH_IPCHKSUM
+u16_t uip_ipchksum( void )
+{
+ u16_t sum;
+
+ sum = chksum( 0, &uip_buf[UIP_LLH_LEN], UIP_IPH_LEN );
+ DEBUG_PRINTF( "uip_ipchksum: sum 0x%04x\n", sum );
+ return( sum == 0 ) ? 0xffff : htons( sum );
+}
+
+ #endif
+
+/*---------------------------------------------------------------------------*/
+static u16_t upper_layer_chksum( u8_t proto )
+{
+ u16_t upper_layer_len;
+ u16_t sum;
+
+ #if UIP_CONF_IPV6
+ upper_layer_len = ( ((u16_t) (BUF->len[0]) << 8) + BUF->len[1] );
+ #else /* UIP_CONF_IPV6 */
+ upper_layer_len = ( ((u16_t) (BUF->len[0]) << 8) + BUF->len[1] ) - UIP_IPH_LEN;
+ #endif /* UIP_CONF_IPV6 */
+
+ /* 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, ( u8_t * ) &BUF->srcipaddr[0], 2 * sizeof(uip_ipaddr_t) );
+
+ /* Sum TCP header and data. */
+ sum = chksum( sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN], upper_layer_len );
+
+ return( sum == 0 ) ? 0xffff : htons( sum );
+}
+
+/*---------------------------------------------------------------------------*/
+ #if UIP_CONF_IPV6
+u16_t uip_icmp6chksum( void )
+{
+ return upper_layer_chksum( UIP_PROTO_ICMP6 );
+}
+
+ #endif /* UIP_CONF_IPV6 */
+
+/*---------------------------------------------------------------------------*/
+u16_t uip_tcpchksum( void )
+{
+ return upper_layer_chksum( UIP_PROTO_TCP );
+}
+
+/*---------------------------------------------------------------------------*/
+ #if UIP_UDP_CHECKSUMS
+u16_t uip_udpchksum( void )
+{
+ return upper_layer_chksum( UIP_PROTO_UDP );
+}
+
+ #endif /* UIP_UDP_CHECKSUMS */
+#endif /* UIP_ARCH_CHKSUM */
+
+/*---------------------------------------------------------------------------*/
+void uip_init( void )
+{
+ for( c = 0; c < UIP_LISTENPORTS; ++c )
+ {
+ uip_listenports[c] = 0;
+ }
+
+ for( c = 0; c < UIP_CONNS; ++c )
+ {
+ uip_conns[c].tcpstateflags = UIP_CLOSED;
+ }
+
+ #if UIP_ACTIVE_OPEN
+ lastport = 1024;
+ #endif /* UIP_ACTIVE_OPEN */
+
+ #if UIP_UDP
+ for( c = 0; c < UIP_UDP_CONNS; ++c )
+ {
+ uip_udp_conns[c].lport = 0;
+ }
+
+ #endif /* UIP_UDP */
+
+ /* IPv4 initialization. */
+ #if UIP_FIXEDADDR == 0
+
+ /* uip_hostaddr[0] = uip_hostaddr[1] = 0;*/
+ #endif /* UIP_FIXEDADDR */
+}
+
+/*---------------------------------------------------------------------------*/
+#if UIP_ACTIVE_OPEN
+struct uip_conn *uip_connect( uip_ipaddr_t *ripaddr, u16_t rport )
+{
+ register struct uip_conn *conn, *cconn;
+
+ /* Find an unused local port. */
+again:
+ ++lastport;
+
+ if( lastport >= 32000 )
+ {
+ lastport = 4096;
+ }
+
+ /* Check if this port is already in use, and if so try to find
+ another one. */
+ for( c = 0; c < UIP_CONNS; ++c )
+ {
+ conn = &uip_conns[c];
+ if( conn->tcpstateflags != UIP_CLOSED && conn->lport == htons(lastport) )
+ {
+ goto again;
+ }
+ }
+
+ conn = 0;
+ for( c = 0; c < UIP_CONNS; ++c )
+ {
+ cconn = &uip_conns[c];
+ if( cconn->tcpstateflags == UIP_CLOSED )
+ {
+ conn = cconn;
+ break;
+ }
+
+ if( cconn->tcpstateflags == UIP_TIME_WAIT )
+ {
+ if( conn == 0 || cconn->timer > conn->timer )
+ {
+ conn = cconn;
+ }
+ }
+ }
+
+ if( conn == 0 )
+ {
+ return 0;
+ }
+
+ conn->tcpstateflags = UIP_SYN_SENT;
+
+ conn->snd_nxt[0] = iss[0];
+ conn->snd_nxt[1] = iss[1];
+ conn->snd_nxt[2] = iss[2];
+ conn->snd_nxt[3] = iss[3];
+
+ conn->initialmss = conn->mss = UIP_TCP_MSS;
+
+ conn->len = 1; /* TCP length of the SYN is one. */
+ conn->nrtx = 0;
+ conn->timer = 1; /* Send the SYN next time around. */
+ conn->rto = UIP_RTO;
+ conn->sa = 0;
+ conn->sv = 16; /* Initial value of the RTT variance. */
+ conn->lport = htons( lastport );
+ conn->rport = rport;
+ uip_ipaddr_copy( &conn->ripaddr, ripaddr );
+
+ return conn;
+}
+
+#endif /* UIP_ACTIVE_OPEN */
+
+/*---------------------------------------------------------------------------*/
+#if UIP_UDP
+struct uip_udp_conn *uip_udp_new( uip_ipaddr_t *ripaddr, u16_t rport )
+{
+ register struct uip_udp_conn *conn;
+
+ /* Find an unused local port. */
+again:
+ ++lastport;
+
+ if( lastport >= 32000 )
+ {
+ lastport = 4096;
+ }
+
+ for( c = 0; c < UIP_UDP_CONNS; ++c )
+ {
+ if( uip_udp_conns[c].lport == htons(lastport) )
+ {
+ goto again;
+ }
+ }
+
+ conn = 0;
+ for( c = 0; c < UIP_UDP_CONNS; ++c )
+ {
+ if( uip_udp_conns[c].lport == 0 )
+ {
+ conn = &uip_udp_conns[c];
+ break;
+ }
+ }
+
+ if( conn == 0 )
+ {
+ return 0;
+ }
+
+ conn->lport = HTONS( lastport );
+ conn->rport = rport;
+ if( ripaddr == NULL )
+ {
+ memset( conn->ripaddr, 0, sizeof(uip_ipaddr_t) );
+ }
+ else
+ {
+ uip_ipaddr_copy( &conn->ripaddr, ripaddr );
+ }
+
+ conn->ttl = UIP_TTL;
+
+ return conn;
+}
+
+#endif /* UIP_UDP */
+
+/*---------------------------------------------------------------------------*/
+void uip_unlisten( u16_t port )
+{
+ for( c = 0; c < UIP_LISTENPORTS; ++c )
+ {
+ if( uip_listenports[c] == port )
+ {
+ uip_listenports[c] = 0;
+ return;
+ }
+ }
+}
+
+/*---------------------------------------------------------------------------*/
+void uip_listen( u16_t port )
+{
+ for( c = 0; c < UIP_LISTENPORTS; ++c )
+ {
+ if( uip_listenports[c] == 0 )
+ {
+ uip_listenports[c] = port;
+ return;
+ }
+ }
+}
+
+/*---------------------------------------------------------------------------*/
+
+/* XXX: IP fragment reassembly: not well-tested. */
+#if UIP_REASSEMBLY && !UIP_CONF_IPV6
+ #define UIP_REASS_BUFSIZE ( UIP_BUFSIZE - UIP_LLH_LEN )
+static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];
+static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / ( 8 * 8 )];
+static const u8_t bitmap_bits[8] = { 0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01 };
+static u16_t uip_reasslen;
+static u8_t uip_reassflags;
+ #define UIP_REASS_FLAG_LASTFRAG 0x01
+static u8_t uip_reasstmr;
+
+ #define IP_MF 0x20
+
+static u8_t uip_reass( void )
+{
+ u16_t offset, len;
+ u16_t 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
+ (
+ BUF->srcipaddr[0] == FBUF->srcipaddr[0] &&
+ BUF->srcipaddr[1] == FBUF->srcipaddr[1] &&
+ BUF->destipaddr[0] == FBUF->destipaddr[0] &&
+ BUF->destipaddr[1] == FBUF->destipaddr[1] &&
+ BUF->ipid[0] == FBUF->ipid[0] &&
+ BUF->ipid[1] == FBUF->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)] != (u8_t)~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() );
+
+ return uip_reasslen;
+ }
+ }
+
+nullreturn:
+ return 0;
+}
+
+#endif /* UIP_REASSEMBLY */
+
+/*---------------------------------------------------------------------------*/
+static void uip_add_rcv_nxt( u16_t 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];
+}
+
+/*---------------------------------------------------------------------------*/
+void uip_process( u8_t flag )
+{
+ register struct uip_conn *uip_connr = uip_conn;
+
+ #if UIP_UDP
+ if( flag == UIP_UDP_SEND_CONN )
+ {
+ goto udp_send;
+ }
+
+ #endif /* UIP_UDP */
+
+ uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
+
+ /* Check if we were invoked because of a poll request for a
+ particular connection. */
+ if( flag == UIP_POLL_REQUEST )
+ {
+ if( (uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED && !uip_outstanding(uip_connr) )
+ {
+ uip_flags = UIP_POLL;
+ UIP_APPCALL();
+ goto appsend;
+ }
+
+ goto drop;
+
+ /* Check if we were invoked because of the perodic timer fireing. */
+ }
+ else if( flag == UIP_TIMER )
+ {
+ #if UIP_REASSEMBLY
+ if( uip_reasstmr != 0 )
+ {
+ --uip_reasstmr;
+ }
+
+ #endif /* UIP_REASSEMBLY */
+
+ /* Increase the initial sequence number. */
+ if( ++iss[3] == 0 )
+ {
+ if( ++iss[2] == 0 )
+ {
+ if( ++iss[1] == 0 )
+ {
+ ++iss[0];
+ }
+ }
+ }
+
+ /* Reset the length variables. */
+ uip_len = 0;
+ uip_slen = 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;
+ }
+ }
+ 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) )
+ {
+ uip_connr->timer = uip_connr->timer - 1;
+ 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;
+
+ /* We call UIP_APPCALL() with uip_flags set to
+ UIP_TIMEDOUT to inform the application that the
+ connection has timed out. */
+ uip_flags = UIP_TIMEDOUT;
+ UIP_APPCALL();
+
+ /* 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;
+
+ #if UIP_ACTIVE_OPEN
+
+ case UIP_SYN_SENT:
+ /* In the SYN_SENT state, we retransmit out SYN. */
+ BUF->flags = 0;
+ goto tcp_send_syn;
+ #endif /* UIP_ACTIVE_OPEN */
+
+ 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_APPCALL();
+ 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_APPCALL();
+ goto appsend;
+ }
+ }
+
+ goto drop;
+ }
+
+ #if UIP_UDP
+ if( flag == UIP_UDP_TIMER )
+ {
+ if( uip_udp_conn->lport != 0 )
+ {
+ uip_conn = NULL;
+ uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+ uip_len = uip_slen = 0;
+ uip_flags = UIP_POLL;
+ UIP_UDP_APPCALL();
+ goto udp_send;
+ }
+ else
+ {
+ goto drop;
+ }
+ }
+
+ #endif
+
+ /* This is where the input processing starts. */
+ UIP_STAT( ++uip_stat.ip.recv );
+
+ /* Start of IP input header processing code. */
+ #if UIP_CONF_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 /* UIP_CONF_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 /* UIP_CONF_IPV6 */
+
+ /* Check the size of the packet. If the size reported to us in
+ uip_len is smaller the size reported in the IP header, we assume
+ that the packet has been corrupted in transit. If the size of
+ uip_len is larger than the size reported in the IP packet header,
+ the packet has been padded and we set uip_len to the correct
+ value.. */
+ if( (BUF->len[0] << 8) + BUF->len[1] <= uip_len )
+ {
+ uip_len = ( BUF->len[0] << 8 ) + BUF->len[1];
+ #if UIP_CONF_IPV6
+ uip_len += 40; /* The length reported in the IPv6 header is the
+ length of the payload that follows the
+ header. However, uIP uses the uip_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). */
+ #endif /* UIP_CONF_IPV6 */
+ }
+ else
+ {
+ UIP_LOG( "ip: packet shorter than reported in IP header." );
+ goto drop;
+ }
+
+ #if !UIP_CONF_IPV6
+
+ /* Check the fragment flag. */
+ if( (BUF->ipoffset[0] & 0x3f) != 0 || BUF->ipoffset[1] != 0 )
+ {
+ #if UIP_REASSEMBLY
+ uip_len = uip_reass();
+ if( uip_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 /* UIP_CONF_IPV6 */
+
+ if( uip_ipaddr_cmp(uip_hostaddr, 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 && !UIP_CONF_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
+ DEBUG_PRINTF( "UDP IP checksum 0x%04x\n", uip_ipchksum() );
+ if( BUF->proto == UIP_PROTO_UDP && uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr) /*&&
+ uip_ipchksum() == 0xffff*/ )
+ {
+ goto udp_input;
+ }
+
+ #endif /* UIP_BROADCAST */
+
+ /* Check if the packet is destined for our IP address. */
+ #if !UIP_CONF_IPV6
+ if( !uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr) )
+ {
+ UIP_STAT( ++uip_stat.ip.drop );
+ goto drop;
+ }
+
+ #else /* UIP_CONF_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, uip_hostaddr) && BUF->destipaddr[0] != HTONS(0xff02) )
+ {
+ UIP_STAT( ++uip_stat.ip.drop );
+ goto drop;
+ }
+
+ #endif /* UIP_CONF_IPV6 */
+ }
+
+ #if !UIP_CONF_IPV6
+ if( uip_ipchksum() != 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 /* UIP_CONF_IPV6 */
+
+ if( BUF->proto == UIP_PROTO_TCP )
+ { /* Check for TCP packet. If so,
+ proceed with TCP input
+ processing. */
+ goto tcp_input;
+ }
+
+ #if UIP_UDP
+ if( BUF->proto == UIP_PROTO_UDP )
+ {
+ goto udp_input;
+ }
+
+ #endif /* UIP_UDP */
+
+ #if !UIP_CONF_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_PINGADDRCONF */
+ 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( (uip_hostaddr[0] | uip_hostaddr[1]) == 0 )
+ {
+ uip_hostaddr[0] = BUF->destipaddr[0];
+ uip_hostaddr[1] = BUF->destipaddr[1];
+ }
+
+ #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. */
+ uip_ipaddr_copy( BUF->destipaddr, BUF->srcipaddr );
+ uip_ipaddr_copy( BUF->srcipaddr, uip_hostaddr );
+
+ UIP_STAT( ++uip_stat.icmp.sent );
+ goto send;
+
+ /* End of IPv4 input header processing code. */
+ #else /* !UIP_CONF_IPV6 */
+
+ /* This is IPv6 ICMPv6 processing code. */
+ DEBUG_PRINTF( "icmp6_input: length %d\n", uip_len );
+
+ 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, uip_hostaddr) )
+ {
+ if( ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS )
+ {
+ /* Save the sender's address in our neighbor list. */
+ uip_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;
+
+ uip_ipaddr_copy( ICMPBUF->destipaddr, ICMPBUF->srcipaddr );
+ uip_ipaddr_copy( ICMPBUF->srcipaddr, uip_hostaddr );
+ ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;
+ ICMPBUF->options[1] = 1; /* Options length, 1 = 8 bytes. */
+ memcpy( &(ICMPBUF->options[2]), &uip_ethaddr, sizeof(uip_ethaddr) );
+ ICMPBUF->icmpchksum = 0;
+ ICMPBUF->icmpchksum = ~uip_icmp6chksum();
+ 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;
+
+ uip_ipaddr_copy( BUF->destipaddr, BUF->srcipaddr );
+ uip_ipaddr_copy( BUF->srcipaddr, uip_hostaddr );
+ ICMPBUF->icmpchksum = 0;
+ ICMPBUF->icmpchksum = ~uip_icmp6chksum();
+
+ UIP_STAT( ++uip_stat.icmp.sent );
+ goto send;
+ }
+ else
+ {
+ DEBUG_PRINTF( "Unknown icmp6 message type %d\n", ICMPBUF->type );
+ UIP_STAT( ++uip_stat.icmp.drop );
+ UIP_STAT( ++uip_stat.icmp.typeerr );
+ UIP_LOG( "icmp: unknown ICMP message." );
+ goto drop;
+ }
+
+ /* End of IPv6 ICMP processing. */
+ #endif /* !UIP_CONF_IPV6 */
+
+ #if UIP_UDP
+
+ /* UDP input processing. */
+ udp_input :
+ /* UDP processing is really just a hack. We don't do anything to the
+ UDP/IP headers, but let the UDP application do all the hard
+ work. If the application sets uip_slen, it has a packet to
+ send. */
+ #if UIP_UDP_CHECKSUMS
+ uip_len = uip_len - UIP_IPUDPH_LEN;
+ uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+ if( UDPBUF->udpchksum != 0 && uip_udpchksum() != 0xffff )
+ {
+ UIP_STAT( ++uip_stat.udp.drop );
+ UIP_STAT( ++uip_stat.udp.chkerr );
+ UIP_LOG( "udp: bad checksum." );
+ goto drop;
+ }
+
+ #else /* UIP_UDP_CHECKSUMS */
+ uip_len = uip_len - UIP_IPUDPH_LEN;
+ #endif /* UIP_UDP_CHECKSUMS */
+
+ /* Demultiplex this UDP packet between the UDP "connections". */
+ for( uip_udp_conn = &uip_udp_conns[0]; uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS]; ++uip_udp_conn )
+ {
+ /* If the local UDP port is non-zero, the connection is considered
+ to be used. If so, the local port number is checked against the
+ destination port number in the received packet. If the two port
+ numbers match, the remote port number is checked if the
+ connection is bound to a remote port. Finally, if the
+ connection is bound to a remote IP address, the source IP
+ address of the packet is checked. */
+ if
+ (
+ uip_udp_conn->lport != 0 &&
+ UDPBUF->destport == uip_udp_conn->lport &&
+ (uip_udp_conn->rport == 0 || UDPBUF->srcport == uip_udp_conn->rport) &&
+ (
+ uip_ipaddr_cmp(uip_udp_conn->ripaddr, all_zeroes_addr) ||
+ uip_ipaddr_cmp(uip_udp_conn->ripaddr, all_ones_addr) ||
+ uip_ipaddr_cmp(BUF->srcipaddr, uip_udp_conn->ripaddr)
+ )
+ )
+ {
+ goto udp_found;
+ }
+ }
+
+ UIP_LOG( "udp: no matching connection found" );
+ goto drop;
+
+udp_found:
+ UIP_STAT( ++uip_stat.udp.recv );
+ uip_conn = NULL;
+ uip_flags = UIP_NEWDATA;
+ uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+ uip_slen = 0;
+ UIP_UDP_APPCALL();
+udp_send:
+ if( uip_slen == 0 )
+ {
+ goto drop;
+ }
+
+ uip_len = uip_slen + UIP_IPUDPH_LEN;
+
+ #if UIP_CONF_IPV6
+
+ /* For IPv6, the IP length field does not include the IPv6 IP header
+ length. */
+ BUF->len[0] = ( (uip_len - UIP_IPH_LEN) >> 8 );
+ BUF->len[1] = ( (uip_len - UIP_IPH_LEN) & 0xff );
+ #else /* UIP_CONF_IPV6 */
+ BUF->len[0] = ( uip_len >> 8 );
+ BUF->len[1] = ( uip_len & 0xff );
+ #endif /* UIP_CONF_IPV6 */
+
+ BUF->ttl = uip_udp_conn->ttl;
+ BUF->proto = UIP_PROTO_UDP;
+
+ UDPBUF->udplen = HTONS( uip_slen + UIP_UDPH_LEN );
+ UDPBUF->udpchksum = 0;
+
+ BUF->srcport = uip_udp_conn->lport;
+ BUF->destport = uip_udp_conn->rport;
+
+ uip_ipaddr_copy( BUF->srcipaddr, uip_hostaddr );
+ uip_ipaddr_copy( BUF->destipaddr, uip_udp_conn->ripaddr );
+
+ uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPTCPH_LEN];
+
+ #if UIP_UDP_CHECKSUMS
+
+ /* Calculate UDP checksum. */
+ UDPBUF->udpchksum = ~( uip_udpchksum() );
+ if( UDPBUF->udpchksum == 0 )
+ {
+ UDPBUF->udpchksum = 0xffff;
+ }
+
+ #endif /* UIP_UDP_CHECKSUMS */
+ UIP_STAT( ++uip_stat.udp.sent );
+ goto ip_send_nolen;
+ #endif /* UIP_UDP */
+
+ /* TCP input processing. */
+ tcp_input : UIP_STAT( ++uip_stat.tcp.recv );
+
+ /* Start of TCP input header processing code. */
+ if( uip_tcpchksum() != 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. */
+ for( uip_connr = &uip_conns[0]; uip_connr <= &uip_conns[UIP_CONNS - 1]; ++uip_connr )
+ {
+ if
+ (
+ uip_connr->tcpstateflags != UIP_CLOSED &&
+ BUF->destport == uip_connr->lport &&
+ BUF->srcport == uip_connr->rport &&
+ uip_ipaddr_cmp(BUF->srcipaddr, uip_connr->ripaddr)
+ )
+ {
+ 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. */
+ for( c = 0; c < UIP_LISTENPORTS; ++c )
+ {
+ if( tmp16 == uip_listenports[c] )
+ {
+ 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;
+ uip_len = UIP_IPTCPH_LEN;
+ BUF->tcpoffset = 5 << 4;
+
+ /* Flip the seqno and ackno fields in the TCP header. */
+ c = BUF->seqno[3];
+ BUF->seqno[3] = BUF->ackno[3];
+ BUF->ackno[3] = c;
+
+ c = BUF->seqno[2];
+ BUF->seqno[2] = BUF->ackno[2];
+ BUF->ackno[2] = c;
+
+ c = BUF->seqno[1];
+ BUF->seqno[1] = BUF->ackno[1];
+ BUF->ackno[1] = c;
+
+ c = BUF->seqno[0];
+ BUF->seqno[0] = BUF->ackno[0];
+ BUF->ackno[0] = c;
+
+ /* 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. */
+ uip_ipaddr_copy( BUF->destipaddr, BUF->srcipaddr );
+ uip_ipaddr_copy( BUF->srcipaddr, uip_hostaddr );
+
+ /* 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 we check if there are any connections avaliable. Unused
+ connections are kept in the same table as used connections, but
+ unused ones have the tcpstate set to CLOSED. Also, connections in
+ TIME_WAIT are kept track of and we'll use the oldest one if no
+ CLOSED connections are found. Thanks to Eddie C. Dost for a very
+ nice algorithm for the TIME_WAIT search. */
+ uip_connr = 0;
+ for( c = 0; c < UIP_CONNS; ++c )
+ {
+ if( uip_conns[c].tcpstateflags == UIP_CLOSED )
+ {
+ uip_connr = &uip_conns[c];
+ break;
+ }
+
+ if( uip_conns[c].tcpstateflags == UIP_TIME_WAIT )
+ {
+ if( uip_connr == 0 || uip_conns[c].timer > uip_connr->timer )
+ {
+ uip_connr = &uip_conns[c];
+ }
+ }
+ }
+
+ if( uip_connr == 0 )
+ {
+ /* All connections are used already, we drop packet and hope that
+ the remote end will retransmit the packet at a time when we
+ have more spare connections. */
+ UIP_STAT( ++uip_stat.tcp.syndrop );
+ UIP_LOG( "tcp: found no unused connections." );
+ goto drop;
+ }
+
+ uip_conn = uip_connr;
+
+ /* Fill in the necessary fields for the new connection. */
+ uip_connr->rto = uip_connr->timer = UIP_RTO;
+ uip_connr->sa = 0;
+ uip_connr->sv = 4;
+ uip_connr->nrtx = 0;
+ uip_connr->lport = BUF->destport;
+ uip_connr->rport = BUF->srcport;
+ uip_ipaddr_copy( uip_connr->ripaddr, BUF->srcipaddr );
+ uip_connr->tcpstateflags = UIP_SYN_RCVD;
+
+ uip_connr->snd_nxt[0] = iss[0];
+ uip_connr->snd_nxt[1] = iss[1];
+ uip_connr->snd_nxt[2] = iss[2];
+ uip_connr->snd_nxt[3] = iss[3];
+ uip_connr->len = 1;
+
+ /* rcv_nxt should be the seqno from the incoming packet + 1. */
+ uip_connr->rcv_nxt[3] = BUF->seqno[3];
+ uip_connr->rcv_nxt[2] = BUF->seqno[2];
+ uip_connr->rcv_nxt[1] = BUF->seqno[1];
+ uip_connr->rcv_nxt[0] = BUF->seqno[0];
+ uip_add_rcv_nxt( 1 );
+
+ /* Parse the TCP MSS option, if present. */
+ if( (BUF->tcpoffset & 0xf0) > 0x50 )
+ {
+ for( c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2; )
+ {
+ opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];
+ if( opt == TCP_OPT_END )
+ {
+ /* End of options. */
+ break;
+ }
+ else if( opt == TCP_OPT_NOOP )
+ {
+ ++c;
+
+ /* NOP option. */
+ }
+ else if( opt == TCP_OPT_MSS && uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN )
+ {
+ /* An MSS option with the right option length. */
+ tmp16 = ( (u16_t) uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8 ) | ( u16_t ) uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + c];
+ 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( uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0 )
+ {
+ /* If the length field is zero, the options are malformed
+ and we don't process them further. */
+ break;
+ }
+
+ c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
+ }
+ }
+ }
+
+ /* Our response will be a SYNACK. */
+ #if UIP_ACTIVE_OPEN
+ tcp_send_synack : BUF->flags = TCP_ACK;
+
+tcp_send_syn:
+ BUF->flags |= TCP_SYN;
+ #else /* UIP_ACTIVE_OPEN */
+ tcp_send_synack : BUF->flags = TCP_SYN | TCP_ACK;
+ #endif /* UIP_ACTIVE_OPEN */
+
+ /* 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;
+ uip_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;
+ UIP_LOG( "tcp: got reset, aborting connection." );
+ uip_flags = UIP_ABORT;
+ UIP_APPCALL();
+ goto drop;
+ }
+
+ /* Calculated the length of the data, if the application has sent
+ any data to us. */
+ c = ( BUF->tcpoffset >> 4 ) << 2;
+
+ /* uip_len will contain the length of the actual TCP data. This is
+ calculated by subtracing the length of the TCP header (in
+ c) and the length of the IP header (20 bytes). */
+ uip_len = uip_len - c - 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
+ (
+ (uip_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_flags = UIP_CONNECTED;
+ uip_connr->len = 0;
+ if( uip_len > 0 )
+ {
+ uip_flags |= UIP_NEWDATA;
+ uip_add_rcv_nxt( uip_len );
+ }
+
+ uip_slen = 0;
+ UIP_APPCALL();
+ goto appsend;
+ }
+
+ goto drop;
+ #if UIP_ACTIVE_OPEN
+
+ 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( c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2; )
+ {
+ opt = uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + c];
+ if( opt == TCP_OPT_END )
+ {
+ /* End of options. */
+ break;
+ }
+ else if( opt == TCP_OPT_NOOP )
+ {
+ ++c;
+
+ /* NOP option. */
+ }
+ else if( opt == TCP_OPT_MSS && uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN )
+ {
+ /* An MSS option with the right option length. */
+ tmp16 = ( uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8 ) | uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];
+ 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( uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0 )
+ {
+ /* If the length field is zero, the options are malformed
+ and we don't process them further. */
+ break;
+ }
+
+ c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
+ }
+ }
+ }
+
+ 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];
+ uip_add_rcv_nxt( 1 );
+ uip_flags = UIP_CONNECTED | UIP_NEWDATA;
+ uip_connr->len = 0;
+ uip_len = 0;
+ uip_slen = 0;
+ UIP_APPCALL();
+ goto appsend;
+ }
+
+ /* Inform the application that the connection failed */
+ uip_flags = UIP_ABORT;
+ UIP_APPCALL();
+
+ /* The connection is closed after we send the RST */
+ uip_conn->tcpstateflags = UIP_CLOSED;
+ goto reset;
+ #endif /* UIP_ACTIVE_OPEN */
+
+ case UIP_ESTABLISHED:
+ /* In the ESTABLISHED state, we call upon the application to feed
+ data into the uip_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( 1 + uip_len );
+ uip_flags |= UIP_CLOSE;
+ if( uip_len > 0 )
+ {
+ uip_flags |= UIP_NEWDATA;
+ }
+
+ UIP_APPCALL();
+ uip_connr->len = 1;
+ uip_connr->tcpstateflags = UIP_LAST_ACK;
+ uip_connr->nrtx = 0;
+ 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 > uip_len )
+ {
+ /* There is more urgent data in the next segment to come. */
+ uip_urglen = uip_len;
+ }
+
+ uip_add_rcv_nxt( uip_urglen );
+ uip_len -= uip_urglen;
+ uip_urgdata = uip_appdata;
+ uip_appdata += uip_urglen;
+ }
+ else
+ {
+ uip_urglen = 0;
+ #else /* UIP_URGDATA > 0 */
+ uip_appdata = ( ( char * ) uip_appdata ) + ( (BUF->urgp[0] << 8) | BUF->urgp[1] );
+ uip_len -= ( BUF->urgp[0] << 8 ) | BUF->urgp[1];
+ #endif /* UIP_URGDATA > 0 */
+ }
+
+ /* If uip_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( uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED) )
+ {
+ uip_flags |= UIP_NEWDATA;
+ uip_add_rcv_nxt( uip_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 = ( (u16_t) BUF->wnd[0] << 8 ) + ( u16_t ) BUF->wnd[1];
+ if( tmp16 > (uip_connr->initialmss * FRAME_MULTIPLE) || tmp16 == 0 )
+ {
+ tmp16 = uip_connr->initialmss * FRAME_MULTIPLE;
+ }
+
+ 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 global variable uip_len
+ contains the length of the incoming data. The application can
+ access the incoming data through the global pointer
+ uip_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN
+ bytes into the uip_buf array.
+
+ If the application wishes to send any data, this data should be
+ put into the uip_appdata and the length of the data should be
+ put into uip_len. If the application don't have any data to
+ send, uip_len must be set to 0. */
+ if( uip_flags & (UIP_NEWDATA | UIP_ACKDATA) )
+ {
+ uip_slen = 0;
+ UIP_APPCALL();
+
+ appsend:
+ if( uip_flags & UIP_ABORT )
+ {
+ uip_slen = 0;
+ uip_connr->tcpstateflags = UIP_CLOSED;
+ BUF->flags = TCP_RST | TCP_ACK;
+ goto tcp_send_nodata;
+ }
+
+ if( uip_flags & UIP_CLOSE )
+ {
+ uip_slen = 0;
+ uip_connr->len = 1;
+ uip_connr->tcpstateflags = UIP_FIN_WAIT_1;
+ uip_connr->nrtx = 0;
+ BUF->flags = TCP_FIN | TCP_ACK;
+ goto tcp_send_nodata;
+ }
+
+ /* If uip_slen > 0, the application has data to be sent. */
+ if( uip_slen > 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( uip_slen > uip_connr->mss )
+ {
+ uip_slen = uip_connr->mss;
+ }
+
+ /* Remember how much data we send out now so that we know
+ when everything has been acknowledged. */
+ uip_connr->len = uip_slen;
+ }
+ 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. */
+ uip_slen = uip_connr->len;
+ }
+ }
+
+ uip_connr->nrtx = 0;
+ apprexmit:
+ uip_appdata = uip_sappdata;
+
+ /* 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( uip_slen > 0 && uip_connr->len > 0 )
+ {
+ /* Add the length of the IP and TCP headers. */
+ uip_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 )
+ {
+ uip_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;
+ uip_flags = UIP_CLOSE;
+ UIP_APPCALL();
+ }
+
+ 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( uip_len > 0 )
+ {
+ uip_add_rcv_nxt( uip_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;
+ }
+ else
+ {
+ uip_connr->tcpstateflags = UIP_CLOSING;
+ }
+
+ uip_add_rcv_nxt( 1 );
+ uip_flags = UIP_CLOSE;
+ UIP_APPCALL();
+ goto tcp_send_ack;
+ }
+ else if( uip_flags & UIP_ACKDATA )
+ {
+ uip_connr->tcpstateflags = UIP_FIN_WAIT_2;
+ uip_connr->len = 0;
+ goto drop;
+ }
+
+ if( uip_len > 0 )
+ {
+ goto tcp_send_ack;
+ }
+
+ goto drop;
+
+ case UIP_FIN_WAIT_2:
+ if( uip_len > 0 )
+ {
+ uip_add_rcv_nxt( uip_len );
+ }
+
+ if( BUF->flags & TCP_FIN )
+ {
+ uip_connr->tcpstateflags = UIP_TIME_WAIT;
+ uip_connr->timer = 0;
+ uip_add_rcv_nxt( 1 );
+ uip_flags = UIP_CLOSE;
+ UIP_APPCALL();
+ goto tcp_send_ack;
+ }
+
+ if( uip_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;
+ }
+ }
+
+ 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:
+ uip_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;
+
+ uip_ipaddr_copy( BUF->srcipaddr, uip_hostaddr );
+ uip_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;
+ #if UIP_CONF_IPV6
+
+ /* For IPv6, the IP length field does not include the IPv6 IP header
+ length. */
+ BUF->len[0] = ( (uip_len - UIP_IPH_LEN) >> 8 );
+ BUF->len[1] = ( (uip_len - UIP_IPH_LEN) & 0xff );
+ #else /* UIP_CONF_IPV6 */
+ BUF->len[0] = ( uip_len >> 8 );
+ BUF->len[1] = ( uip_len & 0xff );
+ #endif /* UIP_CONF_IPV6 */
+
+ BUF->urgp[0] = BUF->urgp[1] = 0;
+
+ /* Calculate TCP checksum. */
+ BUF->tcpchksum = 0;
+ BUF->tcpchksum = ~( uip_tcpchksum() );
+
+ #if UIP_UDP
+ ip_send_nolen :
+ #endif
+ #if UIP_CONF_IPV6
+ BUF->vtc = 0x60;
+ BUF->tcflow = 0x00;
+ BUF->flow = 0x00;
+ #else /* UIP_CONF_IPV6 */
+ BUF->vhl = 0x45;
+ BUF->tos = 0;
+ BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
+ ++ipid;
+ BUF->ipid[0] = ipid >> 8;
+ BUF->ipid[1] = ipid & 0xff;
+
+ /* Calculate IP checksum. */
+ BUF->ipchksum = 0;
+ BUF->ipchksum = ~( uip_ipchksum() );
+ DEBUG_PRINTF( "uip ip_send_nolen: chkecum 0x%04x\n", uip_ipchksum() );
+ #endif /* UIP_CONF_IPV6 */
+
+ UIP_STAT( ++uip_stat.tcp.sent );
+send:
+ DEBUG_PRINTF( "Sending packet with length %d (%d)\n", uip_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:
+ uip_len = 0;
+ uip_flags = 0;
+ return;
+}
+
+/*---------------------------------------------------------------------------*/
+u16_t htons( u16_t val )
+{
+ return HTONS( val );
+}
+
+/*---------------------------------------------------------------------------*/
+void uip_send( const void *data, int len )
+{
+ if( len > 0 )
+ {
+ uip_slen = len;
+ if( data != uip_sappdata )
+ {
+ memcpy( uip_sappdata, (data), uip_slen );
+ }
+ }
+}
+
+/*---------------------------------------------------------------------------*/
+int uip_fast_send( int xARP )
+{
+ ( void ) xARP;
+ #if NOT_YET_COMPLETE
+
+ u16_t tcplen, len1 = 0, uiAccumulatedLen = 0, len_previous = 0, split_len;
+ int iSplitNo = 0;
+ extern int uip_low_level_output( unsigned char *pcBuf, int ilen );
+
+ if( xARP == pdTRUE )
+ {
+ if( BUF->proto == UIP_PROTO_TCP && uip_slen > 1 )
+ {
+ tcplen = uip_len - UIP_TCPIP_HLEN;
+
+ if( tcplen > UIP_TCP_MSS )
+ {
+ split_len = UIP_TCP_MSS;
+ }
+ else
+ {
+ split_len = tcplen / 2;
+ }
+
+ while( tcplen > 0 )
+ {
+ uiAccumulatedLen += len1;
+
+ if( tcplen > split_len )
+ {
+ len1 = split_len;
+ tcplen -= split_len;
+ }
+ else
+ {
+ len1 = tcplen;
+ tcplen = 0;
+ }
+
+ uip_len = len1 + UIP_TCPIP_HLEN;
+ BUF->len[0] = uip_len >> 8;
+ BUF->len[1] = uip_len & 0xff;
+ if( iSplitNo == 0 )
+ {
+ iSplitNo++;
+
+ /* Create the first packet. This is done by altering the length
+ field of the IP header and updating the checksums. */
+ }
+ else
+ {
+ /* Now, create the second packet. To do this, it is not enough to
+ just alter the length field, but we must also update the TCP
+ sequence number and point the uip_appdata to a new place in
+ memory. This place is determined by the length of the first
+ packet (len1). */
+
+ /* uip_appdata += len1;*/
+ memcpy( uip_appdata, ( u8_t * ) uip_appdata + uiAccumulatedLen, len1 );
+ uip_add32( BUF->seqno, len_previous );
+ BUF->seqno[0] = uip_acc32[0];
+ BUF->seqno[1] = uip_acc32[1];
+ BUF->seqno[2] = uip_acc32[2];
+ BUF->seqno[3] = uip_acc32[3];
+ }
+
+ /* Recalculate the TCP checksum. */
+ BUF->tcpchksum = 0;
+ BUF->tcpchksum = ~( uip_tcpchksum() );
+
+ /* Recalculate the IP checksum. */
+ BUF->ipchksum = 0;
+ BUF->ipchksum = ~( uip_ipchksum() );
+
+ /* Transmit the packet. */
+ uip_arp_out();
+ uip_low_level_output( uip_buf, uip_len );
+
+ len_previous = len1;
+ }
+ }
+ else
+ {
+ uip_arp_out();
+ uip_low_level_output( uip_buf, uip_len );
+ }
+ }
+ else
+ {
+ uip_low_level_output( uip_buf, uip_len );
+ }
+
+ #endif
+ return 1;
+}
+
+/** @} */
|