+++ /dev/null
-/**\r
- * \addtogroup uip\r
- * @{\r
- */\r
-\r
-/**\r
- * \file\r
- * The uIP TCP/IP stack code.\r
- * \author Adam Dunkels <adam@dunkels.com>\r
- */\r
-\r
-/*\r
- * Copyright (c) 2001-2003, Adam Dunkels.\r
- * All rights reserved.\r
- *\r
- * Redistribution and use in source and binary forms, with or without\r
- * modification, are permitted provided that the following conditions\r
- * are met:\r
- * 1. Redistributions of source code must retain the above copyright\r
- * notice, this list of conditions and the following disclaimer.\r
- * 2. Redistributions in binary form must reproduce the above copyright\r
- * notice, this list of conditions and the following disclaimer in the\r
- * documentation and/or other materials provided with the distribution.\r
- * 3. The name of the author may not be used to endorse or promote\r
- * products derived from this software without specific prior\r
- * written permission.\r
- *\r
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS\r
- * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY\r
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE\r
- * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\r
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
- *\r
- * This file is part of the uIP TCP/IP stack.\r
- *\r
- * $Id: uip.c,v 1.62.2.10 2003/10/07 13:23:01 adam Exp $\r
- *\r
- */\r
-\r
-/*\r
-This is a small implementation of the IP and TCP protocols (as well as\r
-some basic ICMP stuff). The implementation couples the IP, TCP and the\r
-application layers very tightly. To keep the size of the compiled code\r
-down, this code also features heavy usage of the goto statement.\r
-\r
-The principle is that we have a small buffer, called the uip_buf, in\r
-which the device driver puts an incoming packet. The TCP/IP stack\r
-parses the headers in the packet, and calls upon the application. If\r
-the remote host has sent data to the application, this data is present\r
-in the uip_buf and the application read the data from there. It is up\r
-to the application to put this data into a byte stream if needed. The\r
-application will not be fed with data that is out of sequence.\r
-\r
-If the application whishes to send data to the peer, it should put its\r
-data into the uip_buf, 40 bytes from the start of the buffer. The\r
-TCP/IP stack will calculate the checksums, and fill in the necessary\r
-header fields and finally send the packet back to the peer.\r
-*/\r
-\r
-#include "uip.h"\r
-#include "uipopt.h"\r
-#include "uip_arch.h"\r
-\r
-/*-----------------------------------------------------------------------------------*/\r
-/* Variable definitions. */\r
-\r
-\r
-/* 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 */\r
-#if UIP_FIXEDADDR > 0\r
-const u16_t uip_hostaddr[2] =\r
- {HTONS((UIP_IPADDR0 << 8) | UIP_IPADDR1),\r
- HTONS((UIP_IPADDR2 << 8) | UIP_IPADDR3)};\r
-const u16_t uip_arp_draddr[2] =\r
- {HTONS((UIP_DRIPADDR0 << 8) | UIP_DRIPADDR1),\r
- HTONS((UIP_DRIPADDR2 << 8) | UIP_DRIPADDR3)};\r
-const u16_t uip_arp_netmask[2] =\r
- {HTONS((UIP_NETMASK0 << 8) | UIP_NETMASK1),\r
- HTONS((UIP_NETMASK2 << 8) | UIP_NETMASK3)};\r
-#else\r
-u16_t uip_hostaddr[2];\r
-u16_t uip_arp_draddr[2], uip_arp_netmask[2];\r
-#endif /* UIP_FIXEDADDR */\r
-\r
-u8_t uip_buf[UIP_BUFSIZE+2]; /* The packet buffer that contains\r
- incoming packets. */\r
-volatile u8_t *uip_appdata; /* The uip_appdata pointer points to\r
- application data. */\r
-volatile u8_t *uip_sappdata; /* The uip_appdata pointer points to the\r
- application data which is to be sent. */\r
-#if UIP_URGDATA > 0\r
-volatile u8_t *uip_urgdata; /* The uip_urgdata pointer points to\r
- urgent data (out-of-band data), if\r
- present. */\r
-volatile u8_t uip_urglen, uip_surglen;\r
-#endif /* UIP_URGDATA > 0 */\r
-\r
-volatile u16_t uip_len, uip_slen;\r
- /* The uip_len is either 8 or 16 bits,\r
- depending on the maximum packet\r
- size. */\r
-\r
-volatile u8_t uip_flags; /* The uip_flags variable is used for\r
- communication between the TCP/IP stack\r
- and the application program. */\r
-struct uip_conn *uip_conn; /* uip_conn always points to the current\r
- connection. */\r
-\r
-struct uip_conn uip_conns[UIP_CONNS];\r
- /* The uip_conns array holds all TCP\r
- connections. */\r
-u16_t uip_listenports[UIP_LISTENPORTS];\r
- /* The uip_listenports list all currently\r
- listning ports. */\r
-#if UIP_UDP\r
-struct uip_udp_conn *uip_udp_conn;\r
-struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];\r
-#endif /* UIP_UDP */\r
-\r
-\r
-static u16_t ipid; /* Ths ipid variable is an increasing\r
- number that is used for the IP ID\r
- field. */\r
-\r
-static u8_t iss[4]; /* The iss variable is used for the TCP\r
- initial sequence number. */\r
-\r
-#if UIP_ACTIVE_OPEN\r
-static u16_t lastport; /* Keeps track of the last port used for\r
- a new connection. */\r
-#endif /* UIP_ACTIVE_OPEN */\r
-\r
-/* Temporary variables. */\r
-volatile u8_t uip_acc32[4];\r
-static u8_t c, opt;\r
-static u16_t tmp16;\r
-\r
-/* Structures and definitions. */\r
-#define TCP_FIN 0x01\r
-#define TCP_SYN 0x02\r
-#define TCP_RST 0x04\r
-#define TCP_PSH 0x08\r
-#define TCP_ACK 0x10\r
-#define TCP_URG 0x20\r
-#define TCP_CTL 0x3f\r
-\r
-#define ICMP_ECHO_REPLY 0\r
-#define ICMP_ECHO 8\r
-\r
-/* Macros. */\r
-#define BUF ((uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])\r
-#define FBUF ((uip_tcpip_hdr *)&uip_reassbuf[0])\r
-#define ICMPBUF ((uip_icmpip_hdr *)&uip_buf[UIP_LLH_LEN])\r
-#define UDPBUF ((uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])\r
-\r
-#if UIP_STATISTICS == 1\r
-struct uip_stats uip_stat;\r
-#define UIP_STAT(s) s\r
-#else\r
-#define UIP_STAT(s)\r
-#endif /* UIP_STATISTICS == 1 */\r
-\r
-#if UIP_LOGGING == 1\r
-#include <stdio.h>\r
-void uip_log(char *msg);\r
-#define UIP_LOG(m) uip_log(m)\r
-#else\r
-#define UIP_LOG(m)\r
-#endif /* UIP_LOGGING == 1 */\r
-\r
-/*-----------------------------------------------------------------------------------*/\r
-void\r
-uip_init(void)\r
-{\r
- for(c = 0; c < UIP_LISTENPORTS; ++c) {\r
- uip_listenports[c] = 0;\r
- }\r
- for(c = 0; c < UIP_CONNS; ++c) {\r
- uip_conns[c].tcpstateflags = CLOSED;\r
- }\r
-#if UIP_ACTIVE_OPEN\r
- lastport = 1024;\r
-#endif /* UIP_ACTIVE_OPEN */\r
-\r
-#if UIP_UDP\r
- for(c = 0; c < UIP_UDP_CONNS; ++c) {\r
- uip_udp_conns[c].lport = 0;\r
- }\r
-#endif /* UIP_UDP */\r
-\r
-\r
- /* IPv4 initialization. */\r
-#if UIP_FIXEDADDR == 0\r
- uip_hostaddr[0] = uip_hostaddr[1] = 0;\r
-#endif /* UIP_FIXEDADDR */\r
-\r
-}\r
-/*-----------------------------------------------------------------------------------*/\r
-#if UIP_ACTIVE_OPEN\r
-struct uip_conn *\r
-uip_connect(u16_t *ripaddr, u16_t rport)\r
-{\r
- register struct uip_conn *conn, *cconn;\r
-\r
- /* Find an unused local port. */\r
- again:\r
- ++lastport;\r
-\r
- if(lastport >= 32000) {\r
- lastport = 4096;\r
- }\r
-\r
- /* Check if this port is already in use, and if so try to find\r
- another one. */\r
- for(c = 0; c < UIP_CONNS; ++c) {\r
- conn = &uip_conns[c];\r
- if(conn->tcpstateflags != CLOSED &&\r
- conn->lport == htons(lastport)) {\r
- goto again;\r
- }\r
- }\r
-\r
-\r
- conn = 0;\r
- for(c = 0; c < UIP_CONNS; ++c) {\r
- cconn = &uip_conns[c];\r
- if(cconn->tcpstateflags == CLOSED) {\r
- conn = cconn;\r
- break;\r
- }\r
- if(cconn->tcpstateflags == TIME_WAIT) {\r
- if(conn == 0 ||\r
- cconn->timer > uip_conn->timer) {\r
- conn = cconn;\r
- }\r
- }\r
- }\r
-\r
- if(conn == 0) {\r
- return 0;\r
- }\r
-\r
- conn->tcpstateflags = SYN_SENT;\r
-\r
- conn->snd_nxt[0] = iss[0];\r
- conn->snd_nxt[1] = iss[1];\r
- conn->snd_nxt[2] = iss[2];\r
- conn->snd_nxt[3] = iss[3];\r
-\r
- conn->initialmss = conn->mss = UIP_TCP_MSS;\r
-\r
- conn->len = 1; /* TCP length of the SYN is one. */\r
- conn->nrtx = 0;\r
- conn->timer = 1; /* Send the SYN next time around. */\r
- conn->rto = UIP_RTO;\r
- conn->sa = 0;\r
- conn->sv = 16;\r
- conn->lport = htons(lastport);\r
- conn->rport = rport;\r
- conn->ripaddr[0] = ripaddr[0];\r
- conn->ripaddr[1] = ripaddr[1];\r
-\r
- return conn;\r
-}\r
-#endif /* UIP_ACTIVE_OPEN */\r
-/*-----------------------------------------------------------------------------------*/\r
-#if UIP_UDP\r
-struct uip_udp_conn *\r
-uip_udp_new(u16_t *ripaddr, u16_t rport)\r
-{\r
- register struct uip_udp_conn *conn;\r
-\r
- /* Find an unused local port. */\r
- again:\r
- ++lastport;\r
-\r
- if(lastport >= 32000) {\r
- lastport = 4096;\r
- }\r
-\r
- for(c = 0; c < UIP_UDP_CONNS; ++c) {\r
- if(uip_udp_conns[c].lport == lastport) {\r
- goto again;\r
- }\r
- }\r
-\r
-\r
- conn = 0;\r
- for(c = 0; c < UIP_UDP_CONNS; ++c) {\r
- if(uip_udp_conns[c].lport == 0) {\r
- conn = &uip_udp_conns[c];\r
- break;\r
- }\r
- }\r
-\r
- if(conn == 0) {\r
- return 0;\r
- }\r
-\r
- conn->lport = HTONS(lastport);\r
- conn->rport = HTONS(rport);\r
- conn->ripaddr[0] = ripaddr[0];\r
- conn->ripaddr[1] = ripaddr[1];\r
-\r
- return conn;\r
-}\r
-#endif /* UIP_UDP */\r
-/*-----------------------------------------------------------------------------------*/\r
-void\r
-uip_unlisten(u16_t port)\r
-{\r
- for(c = 0; c < UIP_LISTENPORTS; ++c) {\r
- if(uip_listenports[c] == port) {\r
- uip_listenports[c] = 0;\r
- return;\r
- }\r
- }\r
-}\r
-/*-----------------------------------------------------------------------------------*/\r
-void\r
-uip_listen(u16_t port)\r
-{\r
- for(c = 0; c < UIP_LISTENPORTS; ++c) {\r
- if(uip_listenports[c] == 0) {\r
- uip_listenports[c] = port;\r
- return;\r
- }\r
- }\r
-}\r
-/*-----------------------------------------------------------------------------------*/\r
-/* XXX: IP fragment reassembly: not well-tested. */\r
-\r
-#if UIP_REASSEMBLY\r
-#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)\r
-static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];\r
-static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];\r
-static const u8_t bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f,\r
- 0x0f, 0x07, 0x03, 0x01};\r
-static u16_t uip_reasslen;\r
-static u8_t uip_reassflags;\r
-#define UIP_REASS_FLAG_LASTFRAG 0x01\r
-static u8_t uip_reasstmr;\r
-\r
-#define IP_HLEN 20\r
-#define IP_MF 0x20\r
-\r
-static u8_t\r
-uip_reass(void)\r
-{\r
- u16_t offset, len;\r
- u16_t i;\r
-\r
- /* If ip_reasstmr is zero, no packet is present in the buffer, so we\r
- write the IP header of the fragment into the reassembly\r
- buffer. The timer is updated with the maximum age. */\r
- if(uip_reasstmr == 0) {\r
- memcpy(uip_reassbuf, &BUF->vhl, IP_HLEN);\r
- uip_reasstmr = UIP_REASS_MAXAGE;\r
- uip_reassflags = 0;\r
- /* Clear the bitmap. */\r
- memset(uip_reassbitmap, sizeof(uip_reassbitmap), 0);\r
- }\r
-\r
- /* Check if the incoming fragment matches the one currently present\r
- in the reasembly buffer. If so, we proceed with copying the\r
- fragment into the buffer. */\r
- if(BUF->srcipaddr[0] == FBUF->srcipaddr[0] &&\r
- BUF->srcipaddr[1] == FBUF->srcipaddr[1] &&\r
- BUF->destipaddr[0] == FBUF->destipaddr[0] &&\r
- BUF->destipaddr[1] == FBUF->destipaddr[1] &&\r
- BUF->ipid[0] == FBUF->ipid[0] &&\r
- BUF->ipid[1] == FBUF->ipid[1]) {\r
-\r
- len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;\r
- offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;\r
-\r
- /* If the offset or the offset + fragment length overflows the\r
- reassembly buffer, we discard the entire packet. */\r
- if(offset > UIP_REASS_BUFSIZE ||\r
- offset + len > UIP_REASS_BUFSIZE) {\r
- uip_reasstmr = 0;\r
- goto nullreturn;\r
- }\r
-\r
- /* Copy the fragment into the reassembly buffer, at the right\r
- offset. */\r
- memcpy(&uip_reassbuf[IP_HLEN + offset],\r
- (char *)BUF + (int)((BUF->vhl & 0x0f) * 4),\r
- len);\r
-\r
- /* Update the bitmap. */\r
- if(offset / (8 * 8) == (offset + len) / (8 * 8)) {\r
- /* If the two endpoints are in the same byte, we only update\r
- that byte. */\r
- \r
- uip_reassbitmap[offset / (8 * 8)] |=\r
- bitmap_bits[(offset / 8 ) & 7] &\r
- ~bitmap_bits[((offset + len) / 8 ) & 7];\r
- } else {\r
- /* If the two endpoints are in different bytes, we update the\r
- bytes in the endpoints and fill the stuff inbetween with\r
- 0xff. */\r
- uip_reassbitmap[offset / (8 * 8)] |=\r
- bitmap_bits[(offset / 8 ) & 7];\r
- for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {\r
- uip_reassbitmap[i] = 0xff;\r
- }\r
- uip_reassbitmap[(offset + len) / (8 * 8)] |=\r
- ~bitmap_bits[((offset + len) / 8 ) & 7];\r
- }\r
-\r
- /* If this fragment has the More Fragments flag set to zero, we\r
- know that this is the last fragment, so we can calculate the\r
- size of the entire packet. We also set the\r
- IP_REASS_FLAG_LASTFRAG flag to indicate that we have received\r
- the final fragment. */\r
-\r
- if((BUF->ipoffset[0] & IP_MF) == 0) {\r
- uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;\r
- uip_reasslen = offset + len;\r
- }\r
-\r
- /* Finally, we check if we have a full packet in the buffer. We do\r
- this by checking if we have the last fragment and if all bits\r
- in the bitmap are set. */\r
- if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {\r
- /* Check all bytes up to and including all but the last byte in\r
- the bitmap. */\r
- for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {\r
- if(uip_reassbitmap[i] != 0xff) {\r
- goto nullreturn;\r
- }\r
- }\r
- /* Check the last byte in the bitmap. It should contain just the\r
- right amount of bits. */\r
- if(uip_reassbitmap[uip_reasslen / (8 * 8)] !=\r
- (u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {\r
- goto nullreturn;\r
- }\r
-\r
- /* If we have come this far, we have a full packet in the\r
- buffer, so we allocate a pbuf and copy the packet into it. We\r
- also reset the timer. */\r
- uip_reasstmr = 0;\r
- memcpy(BUF, FBUF, uip_reasslen);\r
-\r
- /* Pretend to be a "normal" (i.e., not fragmented) IP packet\r
- from now on. */\r
- BUF->ipoffset[0] = BUF->ipoffset[1] = 0;\r
- BUF->len[0] = uip_reasslen >> 8;\r
- BUF->len[1] = uip_reasslen & 0xff;\r
- BUF->ipchksum = 0;\r
- BUF->ipchksum = ~(uip_ipchksum());\r
-\r
- return uip_reasslen;\r
- }\r
- }\r
-\r
- nullreturn:\r
- return 0;\r
-}\r
-#endif /* UIP_REASSEMBL */\r
-/*-----------------------------------------------------------------------------------*/\r
-static void\r
-uip_add_rcv_nxt(u16_t n)\r
-{\r
- uip_add32(uip_conn->rcv_nxt, n);\r
- uip_conn->rcv_nxt[0] = uip_acc32[0];\r
- uip_conn->rcv_nxt[1] = uip_acc32[1];\r
- uip_conn->rcv_nxt[2] = uip_acc32[2];\r
- uip_conn->rcv_nxt[3] = uip_acc32[3];\r
-}\r
-/*-----------------------------------------------------------------------------------*/\r
-void\r
-uip_process(u8_t flag)\r
-{\r
- register struct uip_conn *uip_connr = uip_conn;\r
-\r
- uip_appdata = &uip_buf[40 + UIP_LLH_LEN];\r
-\r
-\r
- /* Check if we were invoked because of the perodic timer fireing. */\r
- if(flag == UIP_TIMER) {\r
-#if UIP_REASSEMBLY\r
- if(uip_reasstmr != 0) {\r
- --uip_reasstmr;\r
- }\r
-#endif /* UIP_REASSEMBLY */\r
- /* Increase the initial sequence number. */\r
- if(++iss[3] == 0) {\r
- if(++iss[2] == 0) {\r
- if(++iss[1] == 0) {\r
- ++iss[0];\r
- }\r
- }\r
- }\r
- uip_len = 0;\r
- if(uip_connr->tcpstateflags == TIME_WAIT ||\r
- uip_connr->tcpstateflags == FIN_WAIT_2) {\r
- ++(uip_connr->timer);\r
- if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {\r
- uip_connr->tcpstateflags = CLOSED;\r
- }\r
- } else if(uip_connr->tcpstateflags != CLOSED) {\r
- /* If the connection has outstanding data, we increase the\r
- connection's timer and see if it has reached the RTO value\r
- in which case we retransmit. */\r
- if(uip_outstanding(uip_connr)) {\r
- if(uip_connr->timer-- == 0) {\r
- if(uip_connr->nrtx == UIP_MAXRTX ||\r
- ((uip_connr->tcpstateflags == SYN_SENT ||\r
- uip_connr->tcpstateflags == SYN_RCVD) &&\r
- uip_connr->nrtx == UIP_MAXSYNRTX)) {\r
- uip_connr->tcpstateflags = CLOSED;\r
-\r
- /* We call UIP_APPCALL() with uip_flags set to\r
- UIP_TIMEDOUT to inform the application that the\r
- connection has timed out. */\r
- uip_flags = UIP_TIMEDOUT;\r
- UIP_APPCALL();\r
-\r
- /* We also send a reset packet to the remote host. */\r
- BUF->flags = TCP_RST | TCP_ACK;\r
- goto tcp_send_nodata;\r
- }\r
-\r
- /* Exponential backoff. */\r
- uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4?\r
- 4:\r
- uip_connr->nrtx);\r
- ++(uip_connr->nrtx);\r
- \r
- /* Ok, so we need to retransmit. We do this differently\r
- depending on which state we are in. In ESTABLISHED, we\r
- call upon the application so that it may prepare the\r
- data for the retransmit. In SYN_RCVD, we resend the\r
- SYNACK that we sent earlier and in LAST_ACK we have to\r
- retransmit our FINACK. */\r
- UIP_STAT(++uip_stat.tcp.rexmit);\r
- switch(uip_connr->tcpstateflags & TS_MASK) {\r
- case SYN_RCVD:\r
- /* In the SYN_RCVD state, we should retransmit our\r
- SYNACK. */\r
- goto tcp_send_synack;\r
- \r
-#if UIP_ACTIVE_OPEN\r
- case SYN_SENT:\r
- /* In the SYN_SENT state, we retransmit out SYN. */\r
- BUF->flags = 0;\r
- goto tcp_send_syn;\r
-#endif /* UIP_ACTIVE_OPEN */\r
- \r
- case ESTABLISHED:\r
- /* In the ESTABLISHED state, we call upon the application\r
- to do the actual retransmit after which we jump into\r
- the code for sending out the packet (the apprexmit\r
- label). */\r
- uip_len = 0;\r
- uip_slen = 0;\r
- uip_flags = UIP_REXMIT;\r
- UIP_APPCALL();\r
- goto apprexmit;\r
- \r
- case FIN_WAIT_1:\r
- case CLOSING:\r
- case LAST_ACK:\r
- /* In all these states we should retransmit a FINACK. */\r
- goto tcp_send_finack;\r
- \r
- }\r
- }\r
- } else if((uip_connr->tcpstateflags & TS_MASK) == ESTABLISHED) {\r
- /* If there was no need for a retransmission, we poll the\r
- application for new data. */\r
- uip_len = 0;\r
- uip_slen = 0;\r
- uip_flags = UIP_POLL;\r
- UIP_APPCALL();\r
- goto appsend;\r
- }\r
- }\r
- goto drop;\r
- }\r
-#if UIP_UDP\r
- if(flag == UIP_UDP_TIMER) {\r
- if(uip_udp_conn->lport != 0) {\r
- uip_appdata = &uip_buf[UIP_LLH_LEN + 28];\r
- uip_len = uip_slen = 0;\r
- uip_flags = UIP_POLL;\r
- UIP_UDP_APPCALL();\r
- goto udp_send;\r
- } else {\r
- goto drop;\r
- }\r
- }\r
-#endif\r
-\r
- /* This is where the input processing starts. */\r
- UIP_STAT(++uip_stat.ip.recv);\r
-\r
-\r
- /* Start of IPv4 input header processing code. */\r
-\r
- /* Check validity of the IP header. */\r
- if(BUF->vhl != 0x45) { /* IP version and header length. */\r
- UIP_STAT(++uip_stat.ip.drop);\r
- UIP_STAT(++uip_stat.ip.vhlerr);\r
- UIP_LOG("ip: invalid version or header length.");\r
- goto drop;\r
- }\r
-\r
- /* Check the size of the packet. If the size reported to us in\r
- uip_len doesn't match the size reported in the IP header, there\r
- has been a transmission error and we drop the packet. */\r
-\r
- if(BUF->len[0] != (uip_len >> 8)) { /* IP length, high byte. */\r
- uip_len = (uip_len & 0xff) | (BUF->len[0] << 8);\r
- }\r
- if(BUF->len[1] != (uip_len & 0xff)) { /* IP length, low byte. */\r
- uip_len = (uip_len & 0xff00) | BUF->len[1];\r
- }\r
-\r
- /* Check the fragment flag. */\r
- if((BUF->ipoffset[0] & 0x3f) != 0 ||\r
- BUF->ipoffset[1] != 0) {\r
-#if UIP_REASSEMBLY\r
- uip_len = uip_reass();\r
- if(uip_len == 0) {\r
- goto drop;\r
- }\r
-#else\r
- UIP_STAT(++uip_stat.ip.drop);\r
- UIP_STAT(++uip_stat.ip.fragerr);\r
- UIP_LOG("ip: fragment dropped.");\r
- goto drop;\r
-#endif /* UIP_REASSEMBLY */\r
- }\r
-\r
- /* If we are configured to use ping IP address configuration and\r
- hasn't been assigned an IP address yet, we accept all ICMP\r
- packets. */\r
-#if UIP_PINGADDRCONF\r
- if((uip_hostaddr[0] | uip_hostaddr[1]) == 0) {\r
- if(BUF->proto == UIP_PROTO_ICMP) {\r
- UIP_LOG("ip: possible ping config packet received.");\r
- goto icmp_input;\r
- } else {\r
- UIP_LOG("ip: packet dropped since no address assigned.");\r
- goto drop;\r
- }\r
- }\r
-#endif /* UIP_PINGADDRCONF */\r
-\r
- /* Check if the packet is destined for our IP address. */\r
- if(BUF->destipaddr[0] != uip_hostaddr[0]) {\r
- UIP_STAT(++uip_stat.ip.drop);\r
- UIP_LOG("ip: packet not for us.");\r
- goto drop;\r
- }\r
- if(BUF->destipaddr[1] != uip_hostaddr[1]) {\r
- UIP_STAT(++uip_stat.ip.drop);\r
- UIP_LOG("ip: packet not for us.");\r
- goto drop;\r
- }\r
-\r
-#if 0\r
- // IP checksum is wrong through Netgear DSL router\r
- if (uip_ipchksum() != 0xffff) { /* Compute and check the IP header\r
- checksum. */\r
- UIP_STAT(++uip_stat.ip.drop);\r
- UIP_STAT(++uip_stat.ip.chkerr);\r
- UIP_LOG("ip: bad checksum.");\r
- goto drop;\r
- }\r
-#endif\r
-\r
- if(BUF->proto == UIP_PROTO_TCP) /* Check for TCP packet. If so, jump\r
- to the tcp_input label. */\r
- goto tcp_input;\r
-\r
-#if UIP_UDP\r
- if(BUF->proto == UIP_PROTO_UDP)\r
- goto udp_input;\r
-#endif /* UIP_UDP */\r
-\r
- if(BUF->proto != UIP_PROTO_ICMP) { /* We only allow ICMP packets from\r
- here. */\r
- UIP_STAT(++uip_stat.ip.drop);\r
- UIP_STAT(++uip_stat.ip.protoerr);\r
- UIP_LOG("ip: neither tcp nor icmp.");\r
- goto drop;\r
- }\r
-\r
-#if UIP_PINGADDRCONF\r
- icmp_input:\r
-#endif\r
- UIP_STAT(++uip_stat.icmp.recv);\r
-\r
- /* ICMP echo (i.e., ping) processing. This is simple, we only change\r
- the ICMP type from ECHO to ECHO_REPLY and adjust the ICMP\r
- checksum before we return the packet. */\r
- if(ICMPBUF->type != ICMP_ECHO) {\r
- UIP_STAT(++uip_stat.icmp.drop);\r
- UIP_STAT(++uip_stat.icmp.typeerr);\r
- UIP_LOG("icmp: not icmp echo.");\r
- goto drop;\r
- }\r
-\r
- /* If we are configured to use ping IP address assignment, we use\r
- the destination IP address of this ping packet and assign it to\r
- ourself. */\r
-#if UIP_PINGADDRCONF\r
- if((uip_hostaddr[0] | uip_hostaddr[1]) == 0) {\r
- uip_hostaddr[0] = BUF->destipaddr[0];\r
- uip_hostaddr[1] = BUF->destipaddr[1];\r
- }\r
-#endif /* UIP_PINGADDRCONF */\r
-\r
- ICMPBUF->type = ICMP_ECHO_REPLY;\r
-\r
- if(ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) {\r
- ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;\r
- } else {\r
- ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);\r
- }\r
-\r
- /* Swap IP addresses. */\r
- tmp16 = BUF->destipaddr[0];\r
- BUF->destipaddr[0] = BUF->srcipaddr[0];\r
- BUF->srcipaddr[0] = tmp16;\r
- tmp16 = BUF->destipaddr[1];\r
- BUF->destipaddr[1] = BUF->srcipaddr[1];\r
- BUF->srcipaddr[1] = tmp16;\r
-\r
- UIP_STAT(++uip_stat.icmp.sent);\r
- goto send;\r
-\r
- /* End of IPv4 input header processing code. */\r
-\r
-\r
-#if UIP_UDP\r
- /* UDP input processing. */\r
- udp_input:\r
- /* UDP processing is really just a hack. We don't do anything to the\r
- UDP/IP headers, but let the UDP application do all the hard\r
- work. If the application sets uip_slen, it has a packet to\r
- send. */\r
-#if UIP_UDP_CHECKSUMS\r
- if(uip_udpchksum() != 0xffff) {\r
- UIP_STAT(++uip_stat.udp.drop);\r
- UIP_STAT(++uip_stat.udp.chkerr);\r
- UIP_LOG("udp: bad checksum.");\r
- goto drop;\r
- }\r
-#endif /* UIP_UDP_CHECKSUMS */\r
-\r
- /* Demultiplex this UDP packet between the UDP "connections". */\r
- for(uip_udp_conn = &uip_udp_conns[0];\r
- uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS];\r
- ++uip_udp_conn) {\r
- if(uip_udp_conn->lport != 0 &&\r
- UDPBUF->destport == uip_udp_conn->lport &&\r
- (uip_udp_conn->rport == 0 ||\r
- UDPBUF->srcport == uip_udp_conn->rport) &&\r
- BUF->srcipaddr[0] == uip_udp_conn->ripaddr[0] &&\r
- BUF->srcipaddr[1] == uip_udp_conn->ripaddr[1]) {\r
- goto udp_found;\r
- }\r
- }\r
- goto drop;\r
-\r
- udp_found:\r
- uip_len = uip_len - 28;\r
- uip_appdata = &uip_buf[UIP_LLH_LEN + 28];\r
- uip_flags = UIP_NEWDATA;\r
- uip_slen = 0;\r
- UIP_UDP_APPCALL();\r
- udp_send:\r
- if(uip_slen == 0) {\r
- goto drop;\r
- }\r
- uip_len = uip_slen + 28;\r
-\r
- BUF->len[0] = (uip_len >> 8);\r
- BUF->len[1] = (uip_len & 0xff);\r
-\r
- BUF->proto = UIP_PROTO_UDP;\r
-\r
- UDPBUF->udplen = HTONS(uip_slen + 8);\r
- UDPBUF->udpchksum = 0;\r
-#if UIP_UDP_CHECKSUMS\r
- /* Calculate UDP checksum. */\r
- UDPBUF->udpchksum = ~(uip_udpchksum());\r
- if(UDPBUF->udpchksum == 0) {\r
- UDPBUF->udpchksum = 0xffff;\r
- }\r
-#endif /* UIP_UDP_CHECKSUMS */\r
-\r
- BUF->srcport = uip_udp_conn->lport;\r
- BUF->destport = uip_udp_conn->rport;\r
-\r
- BUF->srcipaddr[0] = uip_hostaddr[0];\r
- BUF->srcipaddr[1] = uip_hostaddr[1];\r
- BUF->destipaddr[0] = uip_udp_conn->ripaddr[0];\r
- BUF->destipaddr[1] = uip_udp_conn->ripaddr[1];\r
-\r
- uip_appdata = &uip_buf[UIP_LLH_LEN + 40];\r
- goto ip_send_nolen;\r
-#endif /* UIP_UDP */\r
-\r
- /* TCP input processing. */\r
- tcp_input:\r
- UIP_STAT(++uip_stat.tcp.recv);\r
-\r
- /* Start of TCP input header processing code. */\r
-\r
-#if 1 // FIXME\r
- if(uip_tcpchksum() != 0xffff) { /* Compute and check the TCP\r
- checksum. */\r
- UIP_STAT(++uip_stat.tcp.drop);\r
- UIP_STAT(++uip_stat.tcp.chkerr);\r
- UIP_LOG("tcp: bad checksum.");\r
- goto drop;\r
- }\r
-#endif\r
-\r
- /* Demultiplex this segment. */\r
- /* First check any active connections. */\r
- for(uip_connr = &uip_conns[0]; uip_connr < &uip_conns[UIP_CONNS]; ++uip_connr) {\r
- if(uip_connr->tcpstateflags != CLOSED &&\r
- BUF->destport == uip_connr->lport &&\r
- BUF->srcport == uip_connr->rport &&\r
- BUF->srcipaddr[0] == uip_connr->ripaddr[0] &&\r
- BUF->srcipaddr[1] == uip_connr->ripaddr[1]) {\r
- goto found;\r
- }\r
- }\r
-\r
- /* If we didn't find and active connection that expected the packet,\r
- either this packet is an old duplicate, or this is a SYN packet\r
- destined for a connection in LISTEN. If the SYN flag isn't set,\r
- it is an old packet and we send a RST. */\r
- if((BUF->flags & TCP_CTL) != TCP_SYN)\r
- goto reset;\r
-\r
- tmp16 = BUF->destport;\r
- /* Next, check listening connections. */\r
- for(c = 0; c < UIP_LISTENPORTS; ++c) {\r
- if(tmp16 == uip_listenports[c])\r
- goto found_listen;\r
- }\r
-\r
- /* No matching connection found, so we send a RST packet. */\r
- UIP_STAT(++uip_stat.tcp.synrst);\r
- reset:\r
-\r
- /* We do not send resets in response to resets. */\r
- if(BUF->flags & TCP_RST)\r
- goto drop;\r
-\r
- UIP_STAT(++uip_stat.tcp.rst);\r
-\r
- BUF->flags = TCP_RST | TCP_ACK;\r
- uip_len = 40;\r
- BUF->tcpoffset = 5 << 4;\r
-\r
- /* Flip the seqno and ackno fields in the TCP header. */\r
- c = BUF->seqno[3];\r
- BUF->seqno[3] = BUF->ackno[3];\r
- BUF->ackno[3] = c;\r
-\r
- c = BUF->seqno[2];\r
- BUF->seqno[2] = BUF->ackno[2];\r
- BUF->ackno[2] = c;\r
-\r
- c = BUF->seqno[1];\r
- BUF->seqno[1] = BUF->ackno[1];\r
- BUF->ackno[1] = c;\r
-\r
- c = BUF->seqno[0];\r
- BUF->seqno[0] = BUF->ackno[0];\r
- BUF->ackno[0] = c;\r
-\r
- /* We also have to increase the sequence number we are\r
- acknowledging. If the least significant byte overflowed, we need\r
- to propagate the carry to the other bytes as well. */\r
- if(++BUF->ackno[3] == 0) {\r
- if(++BUF->ackno[2] == 0) {\r
- if(++BUF->ackno[1] == 0) {\r
- ++BUF->ackno[0];\r
- }\r
- }\r
- }\r
-\r
- /* Swap port numbers. */\r
- tmp16 = BUF->srcport;\r
- BUF->srcport = BUF->destport;\r
- BUF->destport = tmp16;\r
-\r
- /* Swap IP addresses. */\r
- tmp16 = BUF->destipaddr[0];\r
- BUF->destipaddr[0] = BUF->srcipaddr[0];\r
- BUF->srcipaddr[0] = tmp16;\r
- tmp16 = BUF->destipaddr[1];\r
- BUF->destipaddr[1] = BUF->srcipaddr[1];\r
- BUF->srcipaddr[1] = tmp16;\r
-\r
-\r
- /* And send out the RST packet! */\r
- goto tcp_send_noconn;\r
-\r
- /* This label will be jumped to if we matched the incoming packet\r
- with a connection in LISTEN. In that case, we should create a new\r
- connection and send a SYNACK in return. */\r
- found_listen:\r
- /* First we check if there are any connections avaliable. Unused\r
- connections are kept in the same table as used connections, but\r
- unused ones have the tcpstate set to CLOSED. Also, connections in\r
- TIME_WAIT are kept track of and we'll use the oldest one if no\r
- CLOSED connections are found. Thanks to Eddie C. Dost for a very\r
- nice algorithm for the TIME_WAIT search. */\r
- uip_connr = 0;\r
- for(c = 0; c < UIP_CONNS; ++c) {\r
- if(uip_conns[c].tcpstateflags == CLOSED) {\r
- uip_connr = &uip_conns[c];\r
- break;\r
- }\r
- if(uip_conns[c].tcpstateflags == TIME_WAIT) {\r
- if(uip_connr == 0 ||\r
- uip_conns[c].timer > uip_connr->timer) {\r
- uip_connr = &uip_conns[c];\r
- }\r
- }\r
- }\r
-\r
- if(uip_connr == 0) {\r
- /* All connections are used already, we drop packet and hope that\r
- the remote end will retransmit the packet at a time when we\r
- have more spare connections. */\r
- UIP_STAT(++uip_stat.tcp.syndrop);\r
- UIP_LOG("tcp: found no unused connections.");\r
- goto drop;\r
- }\r
- uip_conn = uip_connr;\r
-\r
- /* Fill in the necessary fields for the new connection. */\r
- uip_connr->rto = uip_connr->timer = UIP_RTO;\r
- uip_connr->sa = 0;\r
- uip_connr->sv = 4;\r
- uip_connr->nrtx = 0;\r
- uip_connr->lport = BUF->destport;\r
- uip_connr->rport = BUF->srcport;\r
- uip_connr->ripaddr[0] = BUF->srcipaddr[0];\r
- uip_connr->ripaddr[1] = BUF->srcipaddr[1];\r
- uip_connr->tcpstateflags = SYN_RCVD;\r
-\r
- uip_connr->snd_nxt[0] = iss[0];\r
- uip_connr->snd_nxt[1] = iss[1];\r
- uip_connr->snd_nxt[2] = iss[2];\r
- uip_connr->snd_nxt[3] = iss[3];\r
- uip_connr->len = 1;\r
-\r
- /* rcv_nxt should be the seqno from the incoming packet + 1. */\r
- uip_connr->rcv_nxt[3] = BUF->seqno[3];\r
- uip_connr->rcv_nxt[2] = BUF->seqno[2];\r
- uip_connr->rcv_nxt[1] = BUF->seqno[1];\r
- uip_connr->rcv_nxt[0] = BUF->seqno[0];\r
- uip_add_rcv_nxt(1);\r
-\r
- /* Parse the TCP MSS option, if present. */\r
- if((BUF->tcpoffset & 0xf0) > 0x50) {\r
- for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {\r
- opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];\r
- if(opt == 0x00) {\r
- /* End of options. */ \r
- break;\r
- } else if(opt == 0x01) {\r
- ++c;\r
- /* NOP option. */\r
- } else if(opt == 0x02 &&\r
- uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0x04) {\r
- /* An MSS option with the right option length. */ \r
- tmp16 = ((u16_t)uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |\r
- (u16_t)uip_buf[40 + UIP_LLH_LEN + 3 + c];\r
- uip_connr->initialmss = uip_connr->mss =\r
- tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;\r
- \r
- /* And we are done processing options. */\r
- break;\r
- } else {\r
- /* All other options have a length field, so that we easily\r
- can skip past them. */\r
- if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {\r
- /* If the length field is zero, the options are malformed\r
- and we don't process them further. */\r
- break;\r
- }\r
- c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];\r
- }\r
- }\r
- }\r
-\r
- /* Our response will be a SYNACK. */\r
-#if UIP_ACTIVE_OPEN\r
- tcp_send_synack:\r
- BUF->flags = TCP_ACK;\r
-\r
- tcp_send_syn:\r
- BUF->flags |= TCP_SYN;\r
-#else /* UIP_ACTIVE_OPEN */\r
- tcp_send_synack:\r
- BUF->flags = TCP_SYN | TCP_ACK;\r
-#endif /* UIP_ACTIVE_OPEN */\r
-\r
- /* We send out the TCP Maximum Segment Size option with our\r
- SYNACK. */\r
- BUF->optdata[0] = 2;\r
- BUF->optdata[1] = 4;\r
- BUF->optdata[2] = (UIP_TCP_MSS) / 256;\r
- BUF->optdata[3] = (UIP_TCP_MSS) & 255;\r
- uip_len = 44;\r
- BUF->tcpoffset = 6 << 4;\r
- goto tcp_send;\r
-\r
- /* This label will be jumped to if we found an active connection. */\r
- found:\r
- uip_conn = uip_connr;\r
- uip_flags = 0;\r
-\r
- /* We do a very naive form of TCP reset processing; we just accept\r
- any RST and kill our connection. We should in fact check if the\r
- sequence number of this reset is wihtin our advertised window\r
- before we accept the reset. */\r
- if(BUF->flags & TCP_RST) {\r
- uip_connr->tcpstateflags = CLOSED;\r
- UIP_LOG("tcp: got reset, aborting connection.");\r
- uip_flags = UIP_ABORT;\r
- UIP_APPCALL();\r
- goto drop;\r
- }\r
- /* Calculated the length of the data, if the application has sent\r
- any data to us. */\r
- c = (BUF->tcpoffset >> 4) << 2;\r
- /* uip_len will contain the length of the actual TCP data. This is\r
- calculated by subtracing the length of the TCP header (in\r
- c) and the length of the IP header (20 bytes). */\r
- uip_len = uip_len - c - 20;\r
-\r
- /* First, check if the sequence number of the incoming packet is\r
- what we're expecting next. If not, we send out an ACK with the\r
- correct numbers in. */\r
- if(uip_len > 0 &&\r
- (BUF->seqno[0] != uip_connr->rcv_nxt[0] ||\r
- BUF->seqno[1] != uip_connr->rcv_nxt[1] ||\r
- BUF->seqno[2] != uip_connr->rcv_nxt[2] ||\r
- BUF->seqno[3] != uip_connr->rcv_nxt[3])) {\r
- goto tcp_send_ack;\r
- }\r
-\r
- /* Next, check if the incoming segment acknowledges any outstanding\r
- data. If so, we update the sequence number, reset the length of\r
- the outstanding data, calculate RTT estimations, and reset the\r
- retransmission timer. */\r
- if((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) {\r
- uip_add32(uip_connr->snd_nxt, uip_connr->len);\r
- if(BUF->ackno[0] == uip_acc32[0] &&\r
- BUF->ackno[1] == uip_acc32[1] &&\r
- BUF->ackno[2] == uip_acc32[2] &&\r
- BUF->ackno[3] == uip_acc32[3]) {\r
- /* Update sequence number. */\r
- uip_connr->snd_nxt[0] = uip_acc32[0];\r
- uip_connr->snd_nxt[1] = uip_acc32[1];\r
- uip_connr->snd_nxt[2] = uip_acc32[2];\r
- uip_connr->snd_nxt[3] = uip_acc32[3];\r
- \r
-\r
- /* Do RTT estimation, unless we have done retransmissions. */\r
- if(uip_connr->nrtx == 0) {\r
- signed char m;\r
- m = uip_connr->rto - uip_connr->timer;\r
- /* This is taken directly from VJs original code in his paper */\r
- m = m - (uip_connr->sa >> 3);\r
- uip_connr->sa += m;\r
- if(m < 0) {\r
- m = -m;\r
- }\r
- m = m - (uip_connr->sv >> 2);\r
- uip_connr->sv += m;\r
- uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;\r
-\r
- }\r
- /* Set the acknowledged flag. */\r
- uip_flags = UIP_ACKDATA;\r
- /* Reset the retransmission timer. */\r
- uip_connr->timer = uip_connr->rto;\r
- }\r
-\r
- }\r
-\r
- /* Do different things depending on in what state the connection is. */\r
- switch(uip_connr->tcpstateflags & TS_MASK) {\r
- /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not\r
- implemented, since we force the application to close when the\r
- peer sends a FIN (hence the application goes directly from\r
- ESTABLISHED to LAST_ACK). */\r
- case SYN_RCVD:\r
- /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and\r
- we are waiting for an ACK that acknowledges the data we sent\r
- out the last time. Therefore, we want to have the UIP_ACKDATA\r
- flag set. If so, we enter the ESTABLISHED state. */\r
- if(uip_flags & UIP_ACKDATA) {\r
- uip_connr->tcpstateflags = ESTABLISHED;\r
- uip_flags = UIP_CONNECTED;\r
- uip_connr->len = 0;\r
- if(uip_len > 0) {\r
- uip_flags |= UIP_NEWDATA;\r
- uip_add_rcv_nxt(uip_len);\r
- }\r
- uip_slen = 0;\r
- UIP_APPCALL();\r
- goto appsend;\r
- }\r
- goto drop;\r
-#if UIP_ACTIVE_OPEN\r
- case SYN_SENT:\r
- /* In SYN_SENT, we wait for a SYNACK that is sent in response to\r
- our SYN. The rcv_nxt is set to sequence number in the SYNACK\r
- plus one, and we send an ACK. We move into the ESTABLISHED\r
- state. */\r
- if((uip_flags & UIP_ACKDATA) &&\r
- BUF->flags == (TCP_SYN | TCP_ACK)) {\r
-\r
- /* Parse the TCP MSS option, if present. */\r
- if((BUF->tcpoffset & 0xf0) > 0x50) {\r
- for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {\r
- opt = uip_buf[40 + UIP_LLH_LEN + c];\r
- if(opt == 0x00) {\r
- /* End of options. */ \r
- break;\r
- } else if(opt == 0x01) {\r
- ++c;\r
- /* NOP option. */\r
- } else if(opt == 0x02 &&\r
- uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0x04) {\r
- /* An MSS option with the right option length. */\r
- tmp16 = (uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |\r
- uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];\r
- uip_connr->initialmss =\r
- uip_connr->mss = tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;\r
-\r
- /* And we are done processing options. */\r
- break;\r
- } else {\r
- /* All other options have a length field, so that we easily\r
- can skip past them. */\r
- if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {\r
- /* If the length field is zero, the options are malformed\r
- and we don't process them further. */\r
- break;\r
- }\r
- c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];\r
- }\r
- }\r
- }\r
- uip_connr->tcpstateflags = ESTABLISHED;\r
- uip_connr->rcv_nxt[0] = BUF->seqno[0];\r
- uip_connr->rcv_nxt[1] = BUF->seqno[1];\r
- uip_connr->rcv_nxt[2] = BUF->seqno[2];\r
- uip_connr->rcv_nxt[3] = BUF->seqno[3];\r
- uip_add_rcv_nxt(1);\r
- uip_flags = UIP_CONNECTED | UIP_NEWDATA;\r
- uip_connr->len = 0;\r
- uip_len = 0;\r
- uip_slen = 0;\r
- UIP_APPCALL();\r
- goto appsend;\r
- }\r
- goto reset;\r
-#endif /* UIP_ACTIVE_OPEN */\r
-\r
- case ESTABLISHED:\r
- /* In the ESTABLISHED state, we call upon the application to feed\r
- data into the uip_buf. If the UIP_ACKDATA flag is set, the\r
- application should put new data into the buffer, otherwise we are\r
- retransmitting an old segment, and the application should put that\r
- data into the buffer.\r
-\r
- If the incoming packet is a FIN, we should close the connection on\r
- this side as well, and we send out a FIN and enter the LAST_ACK\r
- state. We require that there is no outstanding data; otherwise the\r
- sequence numbers will be screwed up. */\r
-\r
- if(BUF->flags & TCP_FIN) {\r
- if(uip_outstanding(uip_connr)) {\r
- goto drop;\r
- }\r
- uip_add_rcv_nxt(1 + uip_len);\r
- uip_flags = UIP_CLOSE;\r
- if(uip_len > 0) {\r
- uip_flags |= UIP_NEWDATA;\r
- }\r
- UIP_APPCALL();\r
- uip_connr->len = 1;\r
- uip_connr->tcpstateflags = LAST_ACK;\r
- uip_connr->nrtx = 0;\r
- tcp_send_finack:\r
- BUF->flags = TCP_FIN | TCP_ACK;\r
- goto tcp_send_nodata;\r
- }\r
-\r
- /* Check the URG flag. If this is set, the segment carries urgent\r
- data that we must pass to the application. */\r
- if(BUF->flags & TCP_URG) {\r
-#if UIP_URGDATA > 0\r
- uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];\r
- if(uip_urglen > uip_len) {\r
- /* There is more urgent data in the next segment to come. */\r
- uip_urglen = uip_len;\r
- }\r
- uip_add_rcv_nxt(uip_urglen);\r
- uip_len -= uip_urglen;\r
- uip_urgdata = uip_appdata;\r
- uip_appdata += uip_urglen;\r
- } else {\r
- uip_urglen = 0;\r
-#endif /* UIP_URGDATA > 0 */\r
- uip_appdata += (BUF->urgp[0] << 8) | BUF->urgp[1];\r
- uip_len -= (BUF->urgp[0] << 8) | BUF->urgp[1];\r
- }\r
-\r
-\r
- /* If uip_len > 0 we have TCP data in the packet, and we flag this\r
- by setting the UIP_NEWDATA flag and update the sequence number\r
- we acknowledge. If the application has stopped the dataflow\r
- using uip_stop(), we must not accept any data packets from the\r
- remote host. */\r
- if(uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) {\r
- uip_flags |= UIP_NEWDATA;\r
- uip_add_rcv_nxt(uip_len);\r
- }\r
-\r
- /* Check if the available buffer space advertised by the other end\r
- is smaller than the initial MSS for this connection. If so, we\r
- set the current MSS to the window size to ensure that the\r
- application does not send more data than the other end can\r
- handle.\r
-\r
- If the remote host advertises a zero window, we set the MSS to\r
- the initial MSS so that the application will send an entire MSS\r
- of data. This data will not be acknowledged by the receiver,\r
- and the application will retransmit it. This is called the\r
- "persistent timer" and uses the retransmission mechanim.\r
- */\r
- tmp16 = ((u16_t)BUF->wnd[0] << 8) + (u16_t)BUF->wnd[1];\r
- if(tmp16 > uip_connr->initialmss ||\r
- tmp16 == 0) {\r
- tmp16 = uip_connr->initialmss;\r
- }\r
- uip_connr->mss = tmp16;\r
-\r
- /* If this packet constitutes an ACK for outstanding data (flagged\r
- by the UIP_ACKDATA flag, we should call the application since it\r
- might want to send more data. If the incoming packet had data\r
- from the peer (as flagged by the UIP_NEWDATA flag), the\r
- application must also be notified.\r
-\r
- When the application is called, the global variable uip_len\r
- contains the length of the incoming data. The application can\r
- access the incoming data through the global pointer\r
- uip_appdata, which usually points 40 bytes into the uip_buf\r
- array.\r
-\r
- If the application wishes to send any data, this data should be\r
- put into the uip_appdata and the length of the data should be\r
- put into uip_len. If the application don't have any data to\r
- send, uip_len must be set to 0. */\r
- if(uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) {\r
- uip_slen = 0;\r
- UIP_APPCALL();\r
-\r
- appsend:\r
-\r
- if(uip_flags & UIP_ABORT) {\r
- uip_slen = 0;\r
- uip_connr->tcpstateflags = CLOSED;\r
- BUF->flags = TCP_RST | TCP_ACK;\r
- goto tcp_send_nodata;\r
- }\r
-\r
- if(uip_flags & UIP_CLOSE) {\r
- uip_slen = 0;\r
- uip_connr->len = 1;\r
- uip_connr->tcpstateflags = FIN_WAIT_1;\r
- uip_connr->nrtx = 0;\r
- BUF->flags = TCP_FIN | TCP_ACK;\r
- goto tcp_send_nodata; \r
- }\r
-\r
- /* If uip_slen > 0, the application has data to be sent. */\r
- if(uip_slen > 0) {\r
-\r
- /* If the connection has acknowledged data, the contents of\r
- the ->len variable should be discarded. */\r
- if((uip_flags & UIP_ACKDATA) != 0) {\r
- uip_connr->len = 0;\r
- }\r
-\r
- /* If the ->len variable is non-zero the connection has\r
- already data in transit and cannot send anymore right\r
- now. */\r
- if(uip_connr->len == 0) {\r
-\r
- /* The application cannot send more than what is allowed by\r
- the mss (the minumum of the MSS and the available\r
- window). */\r
- if(uip_slen > uip_connr->mss) {\r
- uip_slen = uip_connr->mss;\r
- }\r
-\r
- /* Remember how much data we send out now so that we know\r
- when everything has been acknowledged. */\r
- uip_connr->len = uip_slen;\r
- } else {\r
-\r
- /* If the application already had unacknowledged data, we\r
- make sure that the application does not send (i.e.,\r
- retransmit) out more than it previously sent out. */\r
- uip_slen = uip_connr->len;\r
- }\r
- } else {\r
- uip_connr->len = 0;\r
- }\r
- uip_connr->nrtx = 0;\r
- apprexmit:\r
- uip_appdata = uip_sappdata;\r
-\r
- /* If the application has data to be sent, or if the incoming\r
- packet had new data in it, we must send out a packet. */\r
- if(uip_slen > 0 && uip_connr->len > 0) {\r
- /* Add the length of the IP and TCP headers. */\r
- uip_len = uip_connr->len + UIP_TCPIP_HLEN;\r
- /* We always set the ACK flag in response packets. */\r
- BUF->flags = TCP_ACK | TCP_PSH;\r
- /* Send the packet. */\r
- goto tcp_send_noopts;\r
- }\r
- /* If there is no data to send, just send out a pure ACK if\r
- there is newdata. */\r
- if(uip_flags & UIP_NEWDATA) {\r
- uip_len = UIP_TCPIP_HLEN;\r
- BUF->flags = TCP_ACK;\r
- goto tcp_send_noopts;\r
- }\r
- }\r
- goto drop;\r
- case LAST_ACK:\r
- /* We can close this connection if the peer has acknowledged our\r
- FIN. This is indicated by the UIP_ACKDATA flag. */\r
- if(uip_flags & UIP_ACKDATA) {\r
- uip_connr->tcpstateflags = CLOSED;\r
- uip_flags = UIP_CLOSE;\r
- UIP_APPCALL();\r
- }\r
- break;\r
-\r
- case FIN_WAIT_1:\r
- /* The application has closed the connection, but the remote host\r
- hasn't closed its end yet. Thus we do nothing but wait for a\r
- FIN from the other side. */\r
- if(uip_len > 0) {\r
- uip_add_rcv_nxt(uip_len);\r
- }\r
- if(BUF->flags & TCP_FIN) {\r
- if(uip_flags & UIP_ACKDATA) {\r
- uip_connr->tcpstateflags = TIME_WAIT;\r
- uip_connr->timer = 0;\r
- uip_connr->len = 0;\r
- } else {\r
- uip_connr->tcpstateflags = CLOSING;\r
- }\r
- uip_add_rcv_nxt(1);\r
- uip_flags = UIP_CLOSE;\r
- UIP_APPCALL();\r
- goto tcp_send_ack;\r
- } else if(uip_flags & UIP_ACKDATA) {\r
- uip_connr->tcpstateflags = FIN_WAIT_2;\r
- uip_connr->len = 0;\r
- goto drop;\r
- }\r
- if(uip_len > 0) {\r
- goto tcp_send_ack;\r
- }\r
- goto drop;\r
-\r
- case FIN_WAIT_2:\r
- if(uip_len > 0) {\r
- uip_add_rcv_nxt(uip_len);\r
- }\r
- if(BUF->flags & TCP_FIN) {\r
- uip_connr->tcpstateflags = TIME_WAIT;\r
- uip_connr->timer = 0;\r
- uip_add_rcv_nxt(1);\r
- uip_flags = UIP_CLOSE;\r
- UIP_APPCALL();\r
- goto tcp_send_ack;\r
- }\r
- if(uip_len > 0) {\r
- goto tcp_send_ack;\r
- }\r
- goto drop;\r
-\r
- case TIME_WAIT:\r
- goto tcp_send_ack;\r
-\r
- case CLOSING:\r
- if(uip_flags & UIP_ACKDATA) {\r
- uip_connr->tcpstateflags = TIME_WAIT;\r
- uip_connr->timer = 0;\r
- }\r
- }\r
- goto drop;\r
-\r
-\r
- /* We jump here when we are ready to send the packet, and just want\r
- to set the appropriate TCP sequence numbers in the TCP header. */\r
- tcp_send_ack:\r
- BUF->flags = TCP_ACK;\r
- tcp_send_nodata:\r
- uip_len = 40;\r
- tcp_send_noopts:\r
- BUF->tcpoffset = 5 << 4;\r
- tcp_send:\r
- /* We're done with the input processing. We are now ready to send a\r
- reply. Our job is to fill in all the fields of the TCP and IP\r
- headers before calculating the checksum and finally send the\r
- packet. */\r
- BUF->ackno[0] = uip_connr->rcv_nxt[0];\r
- BUF->ackno[1] = uip_connr->rcv_nxt[1];\r
- BUF->ackno[2] = uip_connr->rcv_nxt[2];\r
- BUF->ackno[3] = uip_connr->rcv_nxt[3];\r
-\r
- BUF->seqno[0] = uip_connr->snd_nxt[0];\r
- BUF->seqno[1] = uip_connr->snd_nxt[1];\r
- BUF->seqno[2] = uip_connr->snd_nxt[2];\r
- BUF->seqno[3] = uip_connr->snd_nxt[3];\r
-\r
- BUF->proto = UIP_PROTO_TCP;\r
-\r
- BUF->srcport = uip_connr->lport;\r
- BUF->destport = uip_connr->rport;\r
-\r
- BUF->srcipaddr[0] = uip_hostaddr[0];\r
- BUF->srcipaddr[1] = uip_hostaddr[1];\r
- BUF->destipaddr[0] = uip_connr->ripaddr[0];\r
- BUF->destipaddr[1] = uip_connr->ripaddr[1];\r
-\r
-\r
- if(uip_connr->tcpstateflags & UIP_STOPPED) {\r
- /* If the connection has issued uip_stop(), we advertise a zero\r
- window so that the remote host will stop sending data. */\r
- BUF->wnd[0] = BUF->wnd[1] = 0;\r
- } else {\r
- BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);\r
- BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff);\r
- }\r
-\r
- tcp_send_noconn:\r
-\r
- BUF->len[0] = (uip_len >> 8);\r
- BUF->len[1] = (uip_len & 0xff);\r
-\r
- /* Calculate TCP checksum. */\r
- BUF->tcpchksum = 0;\r
- BUF->tcpchksum = ~(uip_tcpchksum());\r
-\r
-\r
-#if UIP_UDP\r
- ip_send_nolen:\r
-#endif\r
-\r
- BUF->vhl = 0x45;\r
- BUF->tos = 0;\r
- BUF->ipoffset[0] = BUF->ipoffset[1] = 0;\r
- BUF->ttl = UIP_TTL;\r
- ++ipid;\r
- BUF->ipid[0] = ipid >> 8;\r
- BUF->ipid[1] = ipid & 0xff;\r
-\r
- /* Calculate IP checksum. */\r
- BUF->ipchksum = 0;\r
- BUF->ipchksum = ~(uip_ipchksum());\r
-\r
- UIP_STAT(++uip_stat.tcp.sent);\r
- send:\r
- UIP_STAT(++uip_stat.ip.sent);\r
- /* Return and let the caller do the actual transmission. */\r
- return;\r
- drop:\r
- uip_len = 0;\r
- return;\r
-}\r
-/*-----------------------------------------------------------------------------------*/\r
-u16_t\r
-htons(u16_t val)\r
-{\r
- return HTONS(val);\r
-}\r
-/*-----------------------------------------------------------------------------------*/\r
-/** @} */\r
projects / freertos / blobdiff