sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
9247dc69ac
nuttx/net/uip/uip-tcpinput.c
patacongo ad1e5e145b Add uIP support more multi-threaded socket access 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@858 42af7a65-404d-4744-a932-0658087f49c3
2008-09-01 13:59:54 +00:00

739 lines
24 KiB
C
Raw Blame History

/****************************************************************************
* net/uip/uip-tcpinput.c
* Handling incoming TCP input
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Adapted for NuttX from logic in uIP which also has a BSD-like license:
*
* Original author Adam Dunkels <adam@dunkels.com>
* Copyright () 2001-2003, Adam Dunkels.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#if defined(CONFIG_NET) && defined(CONFIG_NET_TCP)
#include <sys/types.h>
#include <string.h>
#include <debug.h>
#include <net/uip/uipopt.h>
#include <net/uip/uip.h>
#include <net/uip/uip-arch.h>
#include "uip-internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
#define BUF ((struct uip_tcpip_hdr *)&dev->d_buf[UIP_LLH_LEN])
/****************************************************************************
* Public Variables
****************************************************************************/
/****************************************************************************
* Private Variables
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: uip_tcpinput
*
* Description:
* Handle incoming TCP input
*
* Parameters:
* dev - The device driver structure containing the received TCP packet.
*
* Return:
* None
*
* Assumptions:
* Called from the interrupt level or with interrupts disabled.
*
****************************************************************************/
void uip_tcpinput(struct uip_driver_s *dev)
{
struct uip_conn *conn = NULL;
uint16 tmp16;
uint16 flags;
uint8 opt;
uint8 result;
int len;
int i;
dev->d_snddata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
dev->d_appdata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.recv++;
#endif
/* Start of TCP input header processing code. */
if (uip_tcpchksum(dev) != 0xffff)
{
/* Compute and check the TCP checksum. */
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.drop++;
uip_stat.tcp.chkerr++;
#endif
ndbg("Bad TCP checksum\n");
goto drop;
}
/* Demultiplex this segment. First check any active connections. */
conn = uip_tcpactive(BUF);
if (conn)
{
goto found;
}
/* If we didn't find and active connection that expected the packet,
* either (1) this packet is an old duplicate, or (2) this is a SYN packet
* destined for a connection in LISTEN. If the SYN flag isn't set,
* it is an old packet and we send a RST.
*/
if ((BUF->flags & TCP_CTL) == TCP_SYN)
{
/* This is a SYN packet for a connection. Find the connection
* listening on this port.
*/
tmp16 = BUF->destport;
if (uip_islistener(tmp16))
{
/* We matched the incoming packet with a connection in LISTEN.
* We now need to create a new connection and send a SYNACK in
* response.
*/
/* First allocate a new connection structure and see if there is any
* user application to accept it.
*/
conn = uip_tcpaccept(BUF);
if (conn)
{
/* The connection structure was successfully allocated. Now see
* there is an application waiting to accept the connection (or at
* least queue it it for acceptance).
*/
if (uip_accept(conn, tmp16) != OK)
{
/* No, then we have to give the connection back */
uip_tcpfree(conn);
conn = NULL;
}
}
if (!conn)
{
/* Either (1) all available connections are in use, or (2) there is no
* application in place to accept the connection. We drop packet and hope that
* the remote end will retransmit the packet at a time when we
* have more spare connections or someone waiting to accept the connection.
*/
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.syndrop++;
#endif
ndbg("No free TCP connections\n");
goto drop;
}
uip_incr32(conn->rcv_nxt, 1);
/* Parse the TCP MSS option, if present. */
if ((BUF->tcpoffset & 0xf0) > 0x50)
{
for (i = 0; i < ((BUF->tcpoffset >> 4) - 5) << 2 ;)
{
opt = dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + i];
if (opt == TCP_OPT_END)
{
/* End of options. */
break;
}
else if (opt == TCP_OPT_NOOP)
{
/* NOP option. */
++i;
}
else if (opt == TCP_OPT_MSS &&
dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == TCP_OPT_MSS_LEN)
{
/* An MSS option with the right option length. */
tmp16 = ((uint16)dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + i] << 8) |
(uint16)dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + i];
conn->initialmss = conn->mss =
tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
/* And we are done processing options. */
break;
}
else
{
/* All other options have a length field, so that we easily
* can skip past them.
*/
if (dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == 0)
{
/* If the length field is zero, the options are malformed
* and we don't process them further.
*/
break;
}
i += dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i];
}
}
}
/* Our response will be a SYNACK. */
uip_tcpack(dev, conn, TCP_ACK | TCP_SYN);
return;
}
}
/* This is (1) an old duplicate packet or (2) a SYN packet but with
* no matching listener found. Send RST packet in either case.
*/
/* We do not send resets in response to resets. */
if (BUF->flags & TCP_RST)
{
goto drop;
}
#ifdef CONFIG_NET_STATISTICS
uip_stat.tcp.synrst++;
#endif
uip_tcpreset(dev);
return;
found:
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)
{
conn->tcpstateflags = UIP_CLOSED;
ndbg("RESET - TCP state: UIP_CLOSED\n");
(void)uip_tcpcallback(dev, conn, UIP_ABORT);
goto drop;
}
/* Calculated the length of the data, if the application has sent
* any data to us.
*/
len = (BUF->tcpoffset >> 4) << 2;
/* d_len will contain the length of the actual TCP data. This is
* calculated by subtracting the length of the TCP header (in
* len) and the length of the IP header (20 bytes).
*/
dev->d_len -= (len + UIP_IPH_LEN);
/* First, check if the sequence number of the incoming packet is
* what we're expecting next. If not, we send out an ACK with the
* correct numbers in.
*/
if (!(((conn->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) &&
((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK))))
{
if ((dev->d_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0)) &&
memcmp(BUF->seqno, conn->rcv_nxt, 4) != 0)
{
uip_tcpsend(dev, conn, TCP_ACK, UIP_IPTCPH_LEN);
return;
}
}
/* 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(conn))
{
/* Temporary variables. */
uint8 acc32[4];
uip_add32(conn->snd_nxt, conn->len, acc32);
if (memcmp(BUF->ackno, acc32, 4) == 0)
{
/* Update sequence number. */
memcpy(conn->snd_nxt, acc32, 4);
/* Do RTT estimation, unless we have done retransmissions. */
if (conn->nrtx == 0)
{
signed char m;
m = conn->rto - conn->timer;
/* This is taken directly from VJs original code in his paper */
m = m - (conn->sa >> 3);
conn->sa += m;
if (m < 0)
{
m = -m;
}
m = m - (conn->sv >> 2);
conn->sv += m;
conn->rto = (conn->sa >> 3) + conn->sv;
}
/* Set the acknowledged flag. */
flags = UIP_ACKDATA;
/* Reset the retransmission timer. */
conn->timer = conn->rto;
/* Reset length of outstanding data. */
conn->len = 0;
}
}
/* Do different things depending on in what state the connection is. */
switch (conn->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 (flags & UIP_ACKDATA)
{
conn->tcpstateflags = UIP_ESTABLISHED;
conn->len = 0;
nvdbg("TCP state: UIP_ESTABLISHED\n");
flags = UIP_CONNECTED;
if (dev->d_len > 0)
{
flags |= UIP_NEWDATA;
uip_incr32(conn->rcv_nxt, dev->d_len);
}
dev->d_sndlen = 0;
result = uip_tcpcallback(dev, conn, flags);
uip_tcpappsend(dev, conn, result);
return;
}
goto drop;
case UIP_SYN_SENT:
/* In SYN_SENT, we wait for a SYNACK that is sent in response to
* our SYN. The rcv_nxt is set to sequence number in the SYNACK
* plus one, and we send an ACK. We move into the ESTABLISHED
* state.
*/
if ((flags & UIP_ACKDATA) && (BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK))
{
/* Parse the TCP MSS option, if present. */
if ((BUF->tcpoffset & 0xf0) > 0x50)
{
for (i = 0; i < ((BUF->tcpoffset >> 4) - 5) << 2 ;)
{
opt = dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + i];
if (opt == TCP_OPT_END)
{
/* End of options. */
break;
}
else if (opt == TCP_OPT_NOOP)
{
/* NOP option. */
++i;
}
else if (opt == TCP_OPT_MSS &&
dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == TCP_OPT_MSS_LEN)
{
/* An MSS option with the right option length. */
tmp16 =
(dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + i] << 8) |
dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + i];
conn->initialmss =
conn->mss =
tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
/* And we are done processing options. */
break;
}
else
{
/* All other options have a length field, so that we
* easily can skip past them.
*/
if (dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i] == 0)
{
/* If the length field is zero, the options are
* malformed and we don't process them further.
*/
break;
}
i += dev->d_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + i];
}
}
}
conn->tcpstateflags = UIP_ESTABLISHED;
memcpy(conn->rcv_nxt, BUF->seqno, 4);
nvdbg("TCP state: UIP_ESTABLISHED\n");
uip_incr32(conn->rcv_nxt, 1);
conn->len = 0;
dev->d_len = 0;
dev->d_sndlen = 0;
result = uip_tcpcallback(dev, conn, UIP_CONNECTED | UIP_NEWDATA);
uip_tcpappsend(dev, conn, result);
return;
}
/* Inform the application that the connection failed */
(void)uip_tcpcallback(dev, conn, UIP_ABORT);
/* The connection is closed after we send the RST */
conn->tcpstateflags = UIP_CLOSED;
nvdbg("Connection failed - TCP state: UIP_CLOSED\n");
/* We do not send resets in response to resets. */
if (BUF->flags & TCP_RST)
{
goto drop;
}
uip_tcpreset(dev);
return;
case UIP_ESTABLISHED:
/* In the ESTABLISHED state, we call upon the application to feed
* data into the d_buf. If the UIP_ACKDATA flag is set, the
* application should put new data into the buffer, otherwise we are
* retransmitting an old segment, and the application should put that
* data into the buffer.
*
* If the incoming packet is a FIN, we should close the connection on
* this side as well, and we send out a FIN and enter the LAST_ACK
* state. We require that there is no outstanding data; otherwise the
* sequence numbers will be screwed up.
*/
if (BUF->flags & TCP_FIN && !(conn->tcpstateflags & UIP_STOPPED))
{
if (uip_outstanding(conn))
{
goto drop;
}
uip_incr32(conn->rcv_nxt, dev->d_len + 1);
flags |= UIP_CLOSE;
if (dev->d_len > 0)
{
flags |= UIP_NEWDATA;
}
(void)uip_tcpcallback(dev, conn, flags);
conn->tcpstateflags = UIP_LAST_ACK;
conn->len = 1;
conn->nrtx = 0;
nvdbg("TCP state: UIP_LAST_ACK\n");
uip_tcpsend(dev, conn, TCP_FIN | TCP_ACK, UIP_IPTCPH_LEN);
return;
}
/* 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)
{
#ifdef CONFIG_NET_TCPURGDATA
dev->d_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];
if (dev->d_urglen > dev->d_len)
{
/* There is more urgent data in the next segment to come. */
dev->d_urglen = dev->d_len;
}
uip_incr32(conn->rcv_nxt, dev->d_urglen);
dev->d_len -= dev->d_urglen;
dev->d_urgdata = dev->d_appdata;
dev->d_appdata += dev->d_urglen;
}
else
{
dev->d_urglen = 0;
#else /* CONFIG_NET_TCPURGDATA */
dev->d_appdata =
((uint8*)dev->d_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]);
dev->d_len -=
(BUF->urgp[0] << 8) | BUF->urgp[1];
#endif /* CONFIG_NET_TCPURGDATA */
}
/* If d_len > 0 we have TCP data in the packet, and we flag this
* by setting the UIP_NEWDATA flag and update the sequence number
* we acknowledge. If the application has stopped the dataflow
* using uip_stop(), we must not accept any data packets from the
* remote host.
*/
if (dev->d_len > 0 && !(conn->tcpstateflags & UIP_STOPPED))
{
flags |= UIP_NEWDATA;
uip_incr32(conn->rcv_nxt, dev->d_len);
}
/* Check if the available buffer space advertised by the other end
* is smaller than the initial MSS for this connection. If so, we
* set the current MSS to the window size to ensure that the
* application does not send more data than the other end can
* handle.
*
* If the remote host advertises a zero window, we set the MSS to
* the initial MSS so that the application will send an entire MSS
* of data. This data will not be acknowledged by the receiver,
* and the application will retransmit it. This is called the
* "persistent timer" and uses the retransmission mechanim.
*/
tmp16 = ((uint16)BUF->wnd[0] << 8) + (uint16)BUF->wnd[1];
if (tmp16 > conn->initialmss || tmp16 == 0)
{
tmp16 = conn->initialmss;
}
conn->mss = tmp16;
/* If this packet constitutes an ACK for outstanding data (flagged
* by the UIP_ACKDATA flag, we should call the application since it
* might want to send more data. If the incoming packet had data
* from the peer (as flagged by the UIP_NEWDATA flag), the
* application must also be notified.
*
* When the application is called, the d_len field
* contains the length of the incoming data. The application can
* access the incoming data through the global pointer
* d_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN
* bytes into the d_buf array.
*
* If the application wishes to send any data, this data should be
* put into the d_appdata and the length of the data should be
* put into d_len. If the application don't have any data to
* send, d_len must be set to 0.
*/
if (flags & (UIP_NEWDATA | UIP_ACKDATA))
{
dev->d_sndlen = 0;
result = uip_tcpcallback(dev, conn, flags);
uip_tcpappsend(dev, conn, result);
return;
}
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 (flags & UIP_ACKDATA)
{
conn->tcpstateflags = UIP_CLOSED;
nvdbg("UIP_LAST_ACK TCP state: UIP_CLOSED\n");
(void)uip_tcpcallback(dev, conn, UIP_CLOSE);
}
break;
case UIP_FIN_WAIT_1:
/* The application has closed the connection, but the remote host
* hasn't closed its end yet. Thus we do nothing but wait for a
* FIN from the other side.
*/
if (dev->d_len > 0)
{
uip_incr32(conn->rcv_nxt, dev->d_len);
}
if (BUF->flags & TCP_FIN)
{
if (flags & UIP_ACKDATA)
{
conn->tcpstateflags = UIP_TIME_WAIT;
conn->timer = 0;
conn->len = 0;
nvdbg("TCP state: UIP_TIME_WAIT\n");
}
else
{
conn->tcpstateflags = UIP_CLOSING;
nvdbg("TCP state: UIP_CLOSING\n");
}
uip_incr32(conn->rcv_nxt, 1);
(void)uip_tcpcallback(dev, conn, UIP_CLOSE);
uip_tcpsend(dev, conn, TCP_ACK, UIP_IPTCPH_LEN);
return;
}
else if (flags & UIP_ACKDATA)
{
conn->tcpstateflags = UIP_FIN_WAIT_2;
conn->len = 0;
nvdbg("TCP state: UIP_FIN_WAIT_2\n");
goto drop;
}
if (dev->d_len > 0)
{
uip_tcpsend(dev, conn, TCP_ACK, UIP_IPTCPH_LEN);
return;
}
goto drop;
case UIP_FIN_WAIT_2:
if (dev->d_len > 0)
{
uip_incr32(conn->rcv_nxt, dev->d_len);
}
if (BUF->flags & TCP_FIN)
{
conn->tcpstateflags = UIP_TIME_WAIT;
conn->timer = 0;
nvdbg("TCP state: UIP_TIME_WAIT\n");
uip_incr32(conn->rcv_nxt, 1);
(void)uip_tcpcallback(dev, conn, UIP_CLOSE);
uip_tcpsend(dev, conn, TCP_ACK, UIP_IPTCPH_LEN);
return;
}
if (dev->d_len > 0)
{
uip_tcpsend(dev, conn, TCP_ACK, UIP_IPTCPH_LEN);
return;
}
goto drop;
case UIP_TIME_WAIT:
uip_tcpsend(dev, conn, TCP_ACK, UIP_IPTCPH_LEN);
return;
case UIP_CLOSING:
if (flags & UIP_ACKDATA)
{
conn->tcpstateflags = UIP_TIME_WAIT;
conn->timer = 0;
nvdbg("TCP state: UIP_TIME_WAIT\n");
}
default:
break;
}
drop:
dev->d_len = 0;
}
#endif /* CONFIG_NET && CONFIG_NET_TCP */
Reference in New Issue View Git Blame Copy Permalink