/** alternative tcp_read_poll with condition test function waitfor
* \arg waitfor - simple test function that must not affects mutex_xxx and schedule functionality
* */
buf_t* tcp_read_buf_until (tcp_socket_t *s
, scheduless_condition waitfor, void* waitarg)
{
buf_t *p;
bool_t nonblock = (waitfor == (scheduless_condition)0) && (waitarg != (void*)0);
if (nonblock && tcp_queue_is_empty (s))
return 0;
int ok = tcp_lock_avail(s, TCP_STATES_TRANSFER, waitfor, waitarg);
if (ok != 0)
return (buf_t*)ok;
p = tcp_queue_get (s);
tcp_debug ("tcp_read: received %u bytes, wnd %u (%u).\n",
p->tot_len, s->rcv_wnd, TCP_WND - s->rcv_wnd);
mutex_unlock (&s->lock);
if (p == 0)
return 0;
mutex_lock (&s->ip->lock);
if (! (s->flags & TF_ACK_DELAY) && ! (s->flags & TF_ACK_NOW)) {
tcp_ack (s);
}
mutex_unlock (&s->ip->lock);
return p;
}
void
tcp_recved(struct tcp_pcb *pcb, u16_t len)
{
if ((u32_t)pcb->rcv_wnd + len > TCP_WND) {
pcb->rcv_wnd = TCP_WND;
} else {
pcb->rcv_wnd += len;
}
if (!(pcb->flags & TF_ACK_DELAY) &&
!(pcb->flags & TF_ACK_NOW)) {
/*
* We send an ACK here (if one is not already pending, hence
* the above tests) as tcp_recved() implies that the application
* has processed some data, and so we can open the receiver's
* window to allow more to be transmitted. This could result in
* two ACKs being sent for each received packet in some limited cases
* (where the application is only receiving data, and is slow to
* process it) but it is necessary to guarantee that the sender can
* continue to transmit.
*/
tcp_ack(pcb);
}
LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: recveived %u bytes, wnd %u (%u).\n",
len, pcb->rcv_wnd, TCP_WND - pcb->rcv_wnd));
}
/*-----------------------------------------------------------------------------------*/
void
tcp_recved(struct tcp_pcb *pcb, u16_t len)
{
u16_t new_rcv_wnd;
/* prevent overflow */
new_rcv_wnd = pcb->rcv_wnd + len;
if(pcb->rcv_wnd <= new_rcv_wnd){
pcb->rcv_wnd = new_rcv_wnd;
}else{
pcb->rcv_wnd = TCP_WND;
}
/* window may not exceed TCP_WND */
if(pcb->rcv_wnd > TCP_WND) {
pcb->rcv_wnd = TCP_WND;
}
#if 0
if(!(pcb->flags & TF_ACK_DELAY) ||
!(pcb->flags & TF_ACK_NOW)) {
tcp_ack(pcb);
}
#endif
if ((pcb->rcv_nxt + pcb->rcv_wnd) - pcb->rcv_adv >= 2 * pcb->mss) {
tcp_ack_now(pcb);
}
DEBUGF(TCP_DEBUG, ("tcp_recved: recveived %d bytes, wnd %u (%u).\n",
len, pcb->rcv_wnd, TCP_WND - pcb->rcv_wnd));
}
/* TODO stream is very inefficient of transmiting when receive -
* receiver forces transmiter to accasionaly flush out-buffer
* */
static unsigned short
tcp_stream_getchar (tcp_stream_t *u)
{
unsigned short c;
tcp_socket_t* s = u->socket;
if (!s)
return -1;
mutex_lock (&s->lock);
/* Flush output buffer. */
if (u->outptr > u->outdata) {
stream_flush (u);
mutex_unlock (&s->lock);
socket_flush (s);
mutex_lock (&s->lock);
}
if (u->inbuf)
mutex_unlock (&s->lock);
else {
/* Wait for data. */
while (tcp_queue_is_empty (s)) {
if (!tcp_socket_is_state(s, TCP_STATES_TRANSFER)) {
mutex_unlock (&s->lock);
return -1;
}
mutex_wait (&s->lock);
}
u->inbuf = tcp_queue_get (s);
u->inptr = u->inbuf->payload;
mutex_unlock (&s->lock);
/*debug_printf ("tstream input"); buf_print (u->inbuf);*/
mutex_lock (&s->ip->lock);
if (! (s->flags & TF_ACK_DELAY) &&
! (s->flags & TF_ACK_NOW)) {
tcp_ack (s);
}
mutex_unlock (&s->ip->lock);
}
/* Get byte from buffer. */
c = *u->inptr++;
if (u->inptr >= u->inbuf->payload + u->inbuf->len) {
buf_t *old = u->inbuf;
u->inbuf = old->next;
if (u->inbuf) {
u->inptr = u->inbuf->payload;
old->next = 0;
}
buf_free (old);
}
return c;
}
/*
* Receive len>0 bytes. Return <0 on error.
* When nonblock flag is zero, blocks until data get available (never returns 0).
* When nonblock flag is nonzero, returns 0 if no data is available.
*/
int
tcp_read_poll (tcp_socket_t *s, void *arg, unsigned short len, int nonblock)
{
buf_t *p, *q;
char *buf;
int n;
tcp_debug ("tcp_read(s=%p, arg=%p, len=%u)\n",
(void*) s, arg, len);
if (len == 0) {
return -1;
}
mutex_lock (&s->lock);
while (tcp_queue_is_empty (s)) {
if (s->state != SYN_SENT && s->state != SYN_RCVD &&
s->state != ESTABLISHED) {
mutex_unlock (&s->lock);
tcp_debug ("tcp_read() called in invalid state\n");
return -1;
}
if (nonblock) {
mutex_unlock (&s->lock);
return 0;
}
mutex_wait (&s->lock);
}
p = tcp_queue_get (s);
tcp_debug ("tcp_read: received %u bytes, wnd %u (%u).\n",
p->tot_len, s->rcv_wnd, TCP_WND - s->rcv_wnd);
mutex_unlock (&s->lock);
mutex_lock (&s->ip->lock);
if (! (s->flags & TF_ACK_DELAY) && ! (s->flags & TF_ACK_NOW)) {
tcp_ack (s);
}
mutex_unlock (&s->ip->lock);
/* Copy all chunks. */
buf = arg;
n = 0;
for (q=p; q!=0 && n<len; q=q->next) {
int bytes;
if (q->len == 0)
continue;
bytes = (q->len < len-n) ? q->len : len-n;
memcpy (buf, q->payload, bytes);
n += bytes;
buf += bytes;
}
buf_free (p);
return n;
}
/*-----------------------------------------------------------------------------------*/
void
tcp_recved(struct tcp_pcb *pcb, uint16_t len)
{
pcb->rcv_wnd += len;
if(pcb->rcv_wnd > TCP_WND) {
pcb->rcv_wnd = TCP_WND;
}
if(!(pcb->flags & TF_ACK_DELAY) ||
!(pcb->flags & TF_ACK_NOW)) {
tcp_ack(pcb);
}
DEBUGF(TCP_DEBUG, ("tcp_recved: recveived %d bytes, wnd %u (%u).\n",
len, pcb->rcv_wnd, TCP_WND - pcb->rcv_wnd));
}
/**
* This function should be called by the application when it has
* processed the data. The purpose is to advertise a larger window
* when the data has been processed.
*
* @param pcb the tcp_pcb for which data is read
* @param len the amount of bytes that have been read by the application
*/
void
tcp_recved(struct tcp_pcb *pcb, u16_t len)
{
if ((u32_t)pcb->rcv_wnd + len > TCP_WND) {
pcb->rcv_wnd = TCP_WND;
pcb->rcv_ann_wnd = TCP_WND;
} else {
pcb->rcv_wnd += len;
if (pcb->rcv_wnd >= pcb->mss) {
pcb->rcv_ann_wnd = pcb->rcv_wnd;
}
}
if (!(pcb->flags & TF_ACK_DELAY) &&
!(pcb->flags & TF_ACK_NOW)) {
/*
* We send an ACK here (if one is not already pending, hence
* the above tests) as tcp_recved() implies that the application
* has processed some data, and so we can open the receiver's
* window to allow more to be transmitted. This could result in
* two ACKs being sent for each received packet in some limited cases
* (where the application is only receiving data, and is slow to
* process it) but it is necessary to guarantee that the sender can
* continue to transmit.
*/
tcp_ack(pcb);
}
else if (pcb->flags & TF_ACK_DELAY && pcb->rcv_wnd >= TCP_WND/2) {
/* If we can send a window update such that there is a full
* segment available in the window, do so now. This is sort of
* nagle-like in its goals, and tries to hit a compromise between
* sending acks each time the window is updated, and only sending
* window updates when a timer expires. The "threshold" used
* above (currently TCP_WND/2) can be tuned to be more or less
* aggressive */
tcp_ack_now(pcb);
}
LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: recveived %"U16_F" bytes, wnd %"U16_F" (%"U16_F").\n",
len, pcb->rcv_wnd, TCP_WND - pcb->rcv_wnd));
}
static int
tcp_stream_peekchar (tcp_stream_t *u)
{
tcp_socket_t* s = u->socket;
if (! s)
return -1;
mutex_lock (&s->lock);
/* Flush output buffer. */
if (u->outptr > u->outdata) {
stream_flush (u);
mutex_unlock (&s->lock);
socket_flush (s);
mutex_lock (&s->lock);
}
/* Any data available? */
if (u->inbuf)
mutex_unlock (&s->lock);
else {
if (tcp_queue_is_empty (s)) {
mutex_unlock (&s->lock);
return -1;
}
u->inbuf = tcp_queue_get (s);
u->inptr = u->inbuf->payload;
mutex_unlock (&s->lock);
mutex_lock (&s->ip->lock);
if (! (s->flags & TF_ACK_DELAY) &&
! (s->flags & TF_ACK_NOW)) {
tcp_ack (s);
}
mutex_unlock (&s->ip->lock);
}
return *u->inptr;
}
void tcp_timer(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
int hsec)
{
uint16_t result;
uint8_t hdrlen;
/* Set up for the callback. We can't know in advance if the application
* is going to send a IPv4 or an IPv6 packet, so this setup may not
* actually be used. Furthermore, the TCP logic is required to call
* tcp_ipv4_select() or tcp_ipv6_select() prior to sending any packets.
* We will try to set the correct value here basic on the binding of
* the connection.
*/
#ifdef CONFIG_NET_IPv4
#ifdef CONFIG_NET_IPv6
if (conn->domain == PF_INET)
#endif
{
hdrlen = IPv4TCP_HDRLEN;
tcp_ipv4_select(dev);
}
#endif /* CONFIG_NET_IPv4 */
#ifdef CONFIG_NET_IPv6
#ifdef CONFIG_NET_IPv4
else
#endif
{
hdrlen = IPv6TCP_HDRLEN;
tcp_ipv6_select(dev);
}
#endif /* CONFIG_NET_IPv6 */
/* Increase the TCP sequence number */
tcp_nextsequence();
/* Reset the length variables. */
dev->d_len = 0;
dev->d_sndlen = 0;
/* Check if the connection is in a state in which we simply wait
* for the connection to time out. If so, we increase the
* connection's timer and remove the connection if it times
* out.
*/
if (conn->tcpstateflags == TCP_TIME_WAIT ||
conn->tcpstateflags == TCP_FIN_WAIT_2)
{
unsigned int newtimer;
/* Increment the connection timer */
newtimer = (unsigned int)conn->timer + hsec;
/* Check if the timer exceeds the timeout value */
if (newtimer >= TCP_TIME_WAIT_TIMEOUT)
{
/* Set the timer to the maximum value */
conn->timer = TCP_TIME_WAIT_TIMEOUT;
/* The TCP connection was established and, hence, should be bound
* to a device. Make sure that the polling device is the one that
* we are bound to.
*
* If not, then we will catch the timeout on the next poll from
* the correct device.
*/
DEBUGASSERT(conn->dev != NULL);
if (dev != conn->dev)
{
ninfo("TCP: TCP_CLOSED pending\n");
}
else
{
conn->tcpstateflags = TCP_CLOSED;
/* Notify upper layers about the timeout */
result = tcp_callback(dev, conn, TCP_TIMEDOUT);
ninfo("TCP state: TCP_CLOSED\n");
}
}
else
{
/* No timeout. Just update the incremented timer */
conn->timer = newtimer;
}
}
else if (conn->tcpstateflags != TCP_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 (conn->unacked > 0)
{
/* The connection has outstanding data */
if (conn->timer > hsec)
{
/* Will not yet decrement to zero */
conn->timer -= hsec;
}
else
{
/* Will decrement to zero */
conn->timer = 0;
/* The TCP is connected and, hence, should be bound to a
* device. Make sure that the polling device is the one that
* we are bound to.
*
* If not, then we will catch the timeout on the next poll
* from the correct device.
*/
DEBUGASSERT(conn->dev != NULL);
if (dev != conn->dev)
{
ninfo("TCP: TCP_CLOSED pending\n");
goto done;
}
/* Check for a timeout on connection in the TCP_SYN_RCVD state.
* On such timeouts, we would normally resend the SYNACK until
* the ACK is received, completing the 3-way handshake. But if
* the retry count elapsed, then we must assume that no ACK is
* forthcoming and terminate the attempted connection.
*/
if (conn->tcpstateflags == TCP_SYN_RCVD &&
conn->nrtx >= TCP_MAXSYNRTX)
{
FAR struct tcp_conn_s *listener;
conn->tcpstateflags = TCP_CLOSED;
ninfo("TCP state: TCP_SYN_RCVD->TCP_CLOSED\n");
/* Find the listener for this connection. */
#if defined(CONFIG_NET_IPv4) && defined(CONFIG_NET_IPv6)
listener = tcp_findlistener(conn->lport, conn->domain);
#else
listener = tcp_findlistener(conn->lport);
#endif
if (listener != NULL)
{
/* We call tcp_callback() for the connection with
* TCP_TIMEDOUT to inform the listener that the
* connection has timed out.
*/
result = tcp_callback(dev, listener, TCP_TIMEDOUT);
}
/* We also send a reset packet to the remote host. */
tcp_send(dev, conn, TCP_RST | TCP_ACK, hdrlen);
/* Finally, we must free this TCP connection structure */
tcp_free(conn);
goto done;
}
/* Otherwise, check for a timeout on an established connection.
* If the retry count is exceeded in this case, we should
* close the connection.
*/
else if (
#ifdef CONFIG_NET_TCP_WRITE_BUFFERS
conn->expired > 0 ||
#else
conn->nrtx >= TCP_MAXRTX ||
#endif
(conn->tcpstateflags == TCP_SYN_SENT &&
conn->nrtx >= TCP_MAXSYNRTX)
)
{
conn->tcpstateflags = TCP_CLOSED;
ninfo("TCP state: TCP_CLOSED\n");
/* We call tcp_callback() with TCP_TIMEDOUT to
* inform the application that the connection has
* timed out.
*/
result = tcp_callback(dev, conn, TCP_TIMEDOUT);
/* We also send a reset packet to the remote host. */
tcp_send(dev, conn, TCP_RST | TCP_ACK, hdrlen);
goto done;
}
/* Exponential backoff. */
conn->timer = TCP_RTO << (conn->nrtx > 4 ? 4: conn->nrtx);
(conn->nrtx)++;
/* Ok, so we need to retransmit. We do this differently
* depending on which state we are in. In ESTABLISHED, we
* call upon the application so that it may prepare the
* data for the retransmit. In SYN_RCVD, we resend the
* SYNACK that we sent earlier and in LAST_ACK we have to
* retransmit our FINACK.
*/
#ifdef CONFIG_NET_STATISTICS
g_netstats.tcp.rexmit++;
#endif
switch (conn->tcpstateflags & TCP_STATE_MASK)
{
case TCP_SYN_RCVD:
/* In the SYN_RCVD state, we should retransmit our
* SYNACK.
*/
tcp_ack(dev, conn, TCP_ACK | TCP_SYN);
goto done;
case TCP_SYN_SENT:
/* In the SYN_SENT state, we retransmit out SYN. */
tcp_ack(dev, conn, TCP_SYN);
goto done;
case TCP_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.
*/
result = tcp_callback(dev, conn, TCP_REXMIT);
tcp_rexmit(dev, conn, result);
goto done;
case TCP_FIN_WAIT_1:
case TCP_CLOSING:
case TCP_LAST_ACK:
/* In all these states we should retransmit a FINACK. */
tcp_send(dev, conn, TCP_FIN | TCP_ACK, hdrlen);
goto done;
}
}
}
/* The connection does not have outstanding data. Check if the TCP
* connection has been established.
*/
else if ((conn->tcpstateflags & TCP_STATE_MASK) == TCP_ESTABLISHED)
{
/* The TCP connection is established and, hence, should be bound
* to a device. Make sure that the polling device is the one that
* we are bound to.
*/
DEBUGASSERT(conn->dev != NULL);
if (dev == conn->dev)
{
#ifdef CONFIG_NET_TCP_KEEPALIVE
/* Is this an established connected with KeepAlive enabled? */
if (conn->keepalive)
{
socktimeo_t timeo;
uint32_t saveseq;
/* If this is the first probe, then the keepstart time is
* the time that the last ACK or data was received from the
* remote.
*
* On subsequent retries, keepstart is the time that the
* last probe was sent.
*/
if (conn->keepretries > 0)
{
timeo = (socktimeo_t)conn->keepintvl;
}
else
{
timeo = (socktimeo_t)conn->keepidle;
}
/* Yes... has the idle period elapsed with no data or ACK
* received from the remote peer?
*/
if (net_timeo(conn->keeptime, timeo))
{
/* Yes.. Has the retry count expired? */
if (conn->keepretries >= conn->keepcnt)
{
/* Yes... stop the network monitor, closing the connection and all sockets
* associated with the connection.
*/
tcp_stop_monitor(conn, TCP_ABORT);
}
else
{
unsigned int tcpiplen;
/* No.. we need to send another probe.
*
* Get the size of the IP header and the TCP header.
*/
#ifdef CONFIG_NET_IPv4
#ifdef CONFIG_NET_IPv6
if (conn->domain == PF_INET)
#endif
{
tcpiplen = IPv4_HDRLEN + TCP_HDRLEN;
}
#endif
#ifdef CONFIG_NET_IPv6
#ifdef CONFIG_NET_IPv4
else
#endif
{
tcpiplen = IPv6_HDRLEN + TCP_HDRLEN;
}
#endif
/* And send the probe (along with a garbage byte).
* The packet we sned must have these properties:
*
* - TCP_ACK flag (only) is set.
* - Sequence number is the sequence number of
* previously ACKed data, i.e., the expected
* sequence number minus one.
* - The data payload is one or two bytes.
*
* tcp_send() will send the TCP sequence number as
* conn->sndseq. Rather than creating a new
* interface, we spoof tcp_end() here:
*/
saveseq = tcp_getsequence(conn->sndseq);
tcp_setsequence(conn->sndseq, saveseq - 1);
tcp_send(dev, conn, TCP_ACK, tcpiplen + 1);
tcp_setsequence(conn->sndseq, saveseq);
/* Increment the number of un-ACKed bytes due to the dummy
* byte that we just sent.
*/
conn->unacked++;
#ifdef CONFIG_NET_TCP_WRITE_BUFFERS
/* Increment the un-ACKed sequence number */
conn->sndseq_max++;
#endif
/* Update for the next probe */
conn->keeptime = clock_systimer();
conn->keepretries++;
}
goto done;
}
}
#endif
/* There was no need for a retransmission and there was no
* need to probe the remote peer. We poll the application for
* new outgoing data.
*/
result = tcp_callback(dev, conn, TCP_POLL);
tcp_appsend(dev, conn, result);
goto done;
}
}
}
/* Nothing to be done */
dev->d_len = 0;
done:
return;
}
void tcp_timer(FAR struct net_driver_s *dev, FAR struct tcp_conn_s *conn,
int hsec)
{
uint32_t result;
uint8_t hdrlen;
/* Set up for the callback. We can't know in advance if the application
* is going to send a IPv4 or an IPv6 packet, so this setup may not
* actually be used. Furthermore, the TCP logic is required to call
* tcp_ipv4_select() or tcp_ipv6_select() prior to sending any packets.
* We will try to set the correct value here basic on the binding of
* the connection.
*/
#ifdef CONFIG_NET_IPv4
#ifdef CONFIG_NET_IPv6
if (conn->domain == PF_INET)
#endif
{
hdrlen = IPv4TCP_HDRLEN;
tcp_ipv4_select(dev);
}
#endif /* CONFIG_NET_IPv4 */
#ifdef CONFIG_NET_IPv6
#ifdef CONFIG_NET_IPv4
else
#endif
{
hdrlen = IPv6TCP_HDRLEN;
tcp_ipv6_select(dev);
}
#endif /* CONFIG_NET_IPv6 */
/* Increase the TCP sequence number */
tcp_nextsequence();
/* Reset the length variables. */
dev->d_len = 0;
dev->d_sndlen = 0;
/* Check if the connection is in a state in which we simply wait
* for the connection to time out. If so, we increase the
* connection's timer and remove the connection if it times
* out.
*/
if (conn->tcpstateflags == TCP_TIME_WAIT ||
conn->tcpstateflags == TCP_FIN_WAIT_2)
{
unsigned int newtimer;
/* Increment the connection timer */
newtimer = (unsigned int)conn->timer + hsec;
/* Check if the timer exceeds the timeout value */
if (newtimer >= TCP_TIME_WAIT_TIMEOUT)
{
/* Set the timer to the maximum value */
conn->timer = TCP_TIME_WAIT_TIMEOUT;
#ifdef CONFIG_NETDEV_MULTINIC
/* The TCP connection was established and, hence, should be bound
* to a device. Make sure that the polling device is the one that
* we are bound to.
*
* If not, then we will catch the timeout on the next poll from
* the correct device.
*/
DEBUGASSERT(conn->dev != NULL);
if (dev != conn->dev)
{
nllvdbg("TCP: TCP_CLOSED pending\n");
}
else
#endif
{
conn->tcpstateflags = TCP_CLOSED;
/* Notify upper layers about the timeout */
result = tcp_callback(dev, conn, TCP_TIMEDOUT);
nllvdbg("TCP state: TCP_CLOSED\n");
}
}
else
{
/* No timeout. Just update the incremented timer */
conn->timer = newtimer;
}
}
else if (conn->tcpstateflags != TCP_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 (conn->unacked > 0)
{
/* The connection has outstanding data */
if (conn->timer > hsec)
{
/* Will not yet decrement to zero */
conn->timer -= hsec;
}
else
{
/* Will decrement to zero */
conn->timer = 0;
#ifdef CONFIG_NETDEV_MULTINIC
/* The TCP is connected and, hence, should be bound to a
* device. Make sure that the polling device is the one that
* we are bound to.
*
* If not, then we will catch the timeout on the next poll
* from the correct device.
*/
DEBUGASSERT(conn->dev != NULL);
if (dev != conn->dev)
{
nllvdbg("TCP: TCP_CLOSED pending\n");
goto done;
}
#endif
/* Should we close the connection? */
if (
#ifdef CONFIG_NET_TCP_WRITE_BUFFERS
conn->expired > 0 ||
#else
conn->nrtx == TCP_MAXRTX ||
#endif
((conn->tcpstateflags == TCP_SYN_SENT ||
conn->tcpstateflags == TCP_SYN_RCVD) &&
conn->nrtx == TCP_MAXSYNRTX)
)
{
conn->tcpstateflags = TCP_CLOSED;
nllvdbg("TCP state: TCP_CLOSED\n");
/* We call tcp_callback() with TCP_TIMEDOUT to
* inform the application that the connection has
* timed out.
*/
result = tcp_callback(dev, conn, TCP_TIMEDOUT);
/* We also send a reset packet to the remote host. */
tcp_send(dev, conn, TCP_RST | TCP_ACK, hdrlen);
goto done;
}
/* Exponential backoff. */
conn->timer = TCP_RTO << (conn->nrtx > 4 ? 4: conn->nrtx);
(conn->nrtx)++;
/* Ok, so we need to retransmit. We do this differently
* depending on which state we are in. In ESTABLISHED, we
* call upon the application so that it may prepare the
* data for the retransmit. In SYN_RCVD, we resend the
* SYNACK that we sent earlier and in LAST_ACK we have to
* retransmit our FINACK.
*/
#ifdef CONFIG_NET_STATISTICS
g_netstats.tcp.rexmit++;
#endif
switch (conn->tcpstateflags & TCP_STATE_MASK)
{
case TCP_SYN_RCVD:
/* In the SYN_RCVD state, we should retransmit our
* SYNACK.
*/
tcp_ack(dev, conn, TCP_ACK | TCP_SYN);
goto done;
case TCP_SYN_SENT:
/* In the SYN_SENT state, we retransmit out SYN. */
tcp_ack(dev, conn, TCP_SYN);
goto done;
case TCP_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.
*/
result = tcp_callback(dev, conn, TCP_REXMIT);
tcp_rexmit(dev, conn, result);
goto done;
case TCP_FIN_WAIT_1:
case TCP_CLOSING:
case TCP_LAST_ACK:
/* In all these states we should retransmit a FINACK. */
tcp_send(dev, conn, TCP_FIN | TCP_ACK, hdrlen);
goto done;
}
}
}
/* The connection does not have outstanding data. Check if the TCP
* connection has been established.
*/
else if ((conn->tcpstateflags & TCP_STATE_MASK) == TCP_ESTABLISHED)
{
/* If there was no need for a retransmission, we poll the
* application for new data.
*/
#ifdef CONFIG_NETDEV_MULTINIC
/* The TCP connection is established and, hence, should be bound
* to a device. Make sure that the polling device is the one that
* we are bound to.
*/
DEBUGASSERT(conn->dev != NULL);
if (dev == conn->dev)
#endif
{
result = tcp_callback(dev, conn, TCP_POLL);
tcp_appsend(dev, conn, result);
goto done;
}
}
}
/* Nothing to be done */
dev->d_len = 0;
done:
return;
}
// track a tcp stream. returns the difference between this packet's
// SEQ and the expected next SEQ.
int
IpConnTrack_track_stream(IpConnTrack *self, IpConn *conn,
IpConnTcpQueue *queue,
struct netpkt *pkt,
int buffer_stream) {
netpkt_tcp *tcp;
netpkt_udp *udp;
tcp_seq_t seq;
char *dst, *src;
int len, diff=0;
do {
tcp = pkt->pkt_tcp;
udp = pkt->pkt_udp;
src = pkt->pkt_msg;
len = pkt->pkt_len;
diff = 0;
if( tcp ) {
if( tcp_ack(tcp) ) {
queue->ack = ntohl(tcp->ack_seq);
}
queue->win = ntohs(tcp->window);
seq = ntohl(tcp->seq);
if( !queue->seq_ok ) {
queue->seq_syn = seq;
queue->seq = seq;
queue->seq_ok = 1;
if( tcp_syn(tcp) ) {
queue->seq++;
}
else {
conn->conn_pkt_flags |= CONN_PKT_TCP_MISSED_SYN;
}
}
diff = tcp_seq_diff(seq, queue->seq);
if( diff > 1 ) {
// ignore packets (far) in the future
conn->conn_pkt_flags |= CONN_PKT_TCP_FUTURE_SEQ;
break;
}
src += -diff;
len -= -diff;
if( len <= 0 ) {
// ignore past packets
break;
}
queue->seq += len;
}
else if( udp ) {
}
if( buffer_stream ) {
dst = (char*)array_add(&queue->buf, len);
assertb(dst);
memcpy(dst, src, len);
}
} while(0);
return diff;
}