Diff: modules/pico_tcp.c

Revision:

63:97f481e33cb2

Parent:

58:5f6eedbbbd5b

--- a/modules/pico_tcp.c	Mon Sep 16 12:07:35 2013 +0000
+++ b/modules/pico_tcp.c	Thu Sep 19 12:38:53 2013 +0000
@@ -16,7 +16,6 @@
 #include "pico_queue.h"
 #include "pico_tree.h"
 
-#define TCP_STATE(s) (s->state & PICO_SOCKET_STATE_TCP)
 #define TCP_SOCK(s) ((struct pico_socket_tcp *)s)
 #define SEQN(f) (f?(long_be(((struct pico_tcp_hdr *)(f->transport_hdr))->seq)):0)
 #define ACKN(f) (f?(long_be(((struct pico_tcp_hdr *)(f->transport_hdr))->ack)):0)
@@ -25,7 +24,6 @@
 #define PICO_TCP_RTO_MAX 120000
 #define PICO_TCP_IW 		 2
 #define PICO_TCP_SYN_TO	 1000
-#define PICO_TCP_ZOMBIE_TO 30000
 
 #define PICO_TCP_MAX_CONNECT_RETRIES 7
 
@@ -45,18 +43,9 @@
 #define IS_TCP_HOLDQ_EMPTY(t)   (t->tcpq_hold.size == 0)
 
 #ifdef PICO_SUPPORT_TCP
-#define tcp_dbg_nagle(...) do{}while(0)
-#define tcp_dbg_options(...) do{}while(0)
-
-
 #define tcp_dbg(...) do{}while(0)
 //#define tcp_dbg dbg
 
-struct tcp_port_pair
-{
-	uint16_t local;
-	uint16_t remote;
-};
 
 #ifdef PICO_SUPPORT_MUTEX
 static void * Mutex = NULL;
@@ -107,7 +96,7 @@
 static struct pico_frame *peek_segment(struct pico_tcp_queue *tq, uint32_t seq)
 {
   struct pico_tcp_hdr H;
-  struct pico_frame f = {0};
+  struct pico_frame f = {};
   f.transport_hdr = (uint8_t *) (&H);
   H.seq = long_be(seq);
 
@@ -229,8 +218,8 @@
 };
 
 /* Queues */
-static struct pico_queue tcp_in = {0};
-static struct pico_queue tcp_out = {0};
+static struct pico_queue tcp_in = {};
+static struct pico_queue tcp_out = {};
 
 /* If Nagle enabled, this function can make 1 new segment from smaller segments in hold queue */
 static struct pico_frame * pico_hold_segment_make(struct pico_socket_tcp *t);
@@ -311,7 +300,6 @@
 {
   struct pico_tcp_hdr *hdr;
   struct pico_socket_tcp *t = (struct pico_socket_tcp *)f->sock;
-  IGNORE_PARAMETER(self);
   hdr = (struct pico_tcp_hdr *)f->transport_hdr;
 
   if (f->payload_len > 0) {
@@ -477,7 +465,7 @@
   struct pico_frame *f;
   struct pico_tree_node * index, * temp;
   int cmp;
-  uint16_t count = 0;
+  int count = 0;
 
   pico_tree_foreach_safe(index,&t->tcpq_out.pool,temp){
     f = index->keyValue;
@@ -532,8 +520,7 @@
 {
   struct pico_socket_tcp *t = (struct pico_socket_tcp *)f->sock;
   uint8_t *opt = f->transport_hdr + PICO_SIZE_TCPHDR;
-  uint32_t i = 0;
-  f->timestamp = 0;
+  int i = 0;
   while (i < (f->transport_len - PICO_SIZE_TCPHDR)) {
     uint8_t type =  opt[i++];
     uint8_t len;
@@ -543,23 +530,23 @@
       len = 1;
     if (f->payload && ((opt + i) > f->payload))
       break;
-    tcp_dbg_options("Received option '%d', len = %d \n", type, len);
+    tcp_dbg("Received option '%d', len = %d \n", type, len);
     switch (type) {
       case PICO_TCP_OPTION_NOOP:
       case PICO_TCP_OPTION_END:
         break;
       case PICO_TCP_OPTION_WS:
         if (len != PICO_TCPOPTLEN_WS) {
-          tcp_dbg_options("TCP Window scale: bad len received (%d).\n", len);
+          tcp_dbg("TCP Window scale: bad len received (%d).\n", len);
           i += len - 2;
           break;
         }
         t->recv_wnd_scale = opt[i++];
-        tcp_dbg_options("TCP Window scale: received %d\n", t->recv_wnd_scale);
+        tcp_dbg("TCP Window scale: received %d\n", t->recv_wnd_scale);
         break;
       case PICO_TCP_OPTION_SACK_OK:
         if (len != PICO_TCPOPTLEN_SACK_OK) {
-          tcp_dbg_options("TCP option sack: bad len received.\n");
+          tcp_dbg("TCP option sack: bad len received.\n");
           i += len - 2;
           break;
         }
@@ -568,7 +555,7 @@
       case PICO_TCP_OPTION_MSS: {
         uint16_t mss;
         if (len != PICO_TCPOPTLEN_MSS) {
-          tcp_dbg_options("TCP option mss: bad len received.\n");
+          tcp_dbg("TCP option mss: bad len received.\n");
           i += len - 2;
           break;
         }
@@ -582,7 +569,7 @@
       case PICO_TCP_OPTION_TIMESTAMP: {
         uint32_t tsval, tsecr;
         if (len != PICO_TCPOPTLEN_TIMESTAMP) {
-          tcp_dbg_options("TCP option timestamp: bad len received.\n");
+          tcp_dbg("TCP option timestamp: bad len received.\n");
           i += len - 2;
           break;
         }
@@ -592,6 +579,7 @@
         tsecr = long_from(opt + i);
         f->timestamp = long_be(tsecr);
         i += sizeof(uint32_t);
+
         t->ts_nxt = long_be(tsval);
         break;
       }
@@ -602,7 +590,7 @@
         break;
       }
       default:
-        tcp_dbg_options("TCP: received unsupported option %u\n", type);
+        tcp_dbg("TCP: received unsupported option %u\n", type);
         i += len - 2;
     }
   }
@@ -682,7 +670,7 @@
   t->tcpq_hold.max_size = 2*PICO_TCP_DEFAULT_MSS;
 
   /* enable Nagle by default */
-  t->sock.opt_flags &= ~(1 << PICO_SOCKET_OPT_TCPNODELAY);
+  t->sock.opt_flags &= (~(1 << PICO_SOCKET_OPT_TCPNODELAY));
 
 #ifdef PICO_TCP_SUPPORT_SOCKET_STATS
   pico_timer_add(2000, sock_stats, t);
@@ -721,7 +709,7 @@
       in_frame_off = 0;
       in_frame_len = f->payload_len;
     }
-    if ((in_frame_len + tot_rd_len) > (uint32_t)len) {
+    if ((in_frame_len + tot_rd_len) > len) {
       in_frame_len = len - tot_rd_len;
     }
 
@@ -732,7 +720,7 @@
     tot_rd_len += in_frame_len;
     t->rcv_processed += in_frame_len;
 
-    if ((in_frame_len == 0u) || (in_frame_len == (uint32_t)f->payload_len)) {
+    if ((in_frame_len == 0) || (in_frame_len == f->payload_len)) {
       pico_discard_segment(&t->tcpq_in, f);
     }
   }
@@ -749,7 +737,6 @@
 static void initconn_retry(unsigned long when, void *arg)
 {
   struct pico_socket_tcp *t = (struct pico_socket_tcp *)arg;
-  IGNORE_PARAMETER(when);
   if (TCPSTATE(&t->sock) == PICO_SOCKET_STATE_TCP_SYN_SENT) {
     if (t->backoff > PICO_TCP_MAX_CONNECT_RETRIES) {
       tcp_dbg("TCP> Connection timeout. \n");
@@ -1128,16 +1115,16 @@
     tcp_parse_options(f);
     f->payload = f->transport_hdr + ((hdr->len & 0xf0) >>2);
     f->payload_len = f->transport_len - ((hdr->len & 0xf0) >>2);
-    tcp_dbg("TCP> Received segment. (exp: %x got: %x)\n", t->rcv_nxt, SEQN(f));
 
-    if (seq_compare(SEQN(f), t->rcv_nxt) <= 0) {
+    if (seq_compare(SEQN(f), t->rcv_nxt) >= 0) {
+      struct pico_frame *cpy = pico_frame_copy(f);
       struct pico_frame *nxt;
+      /* Enqueue: try to put into RCV buffer */
+      if (pico_enqueue_segment(&t->tcpq_in, cpy) <= 0) {
+        pico_frame_discard(cpy);
+        return -1;
+      }
       if (seq_compare(SEQN(f), t->rcv_nxt) == 0) { /* Exactly what we expected */
-        struct pico_frame *cpy = pico_frame_copy(f);
-        /* Enqueue: try to put into RCV buffer */
-        if(pico_enqueue_segment(&t->tcpq_in, cpy) <= 0) {
-          pico_frame_discard(cpy);
-        }
         t->rcv_nxt = SEQN(f) + f->payload_len;
         nxt = peek_segment(&t->tcpq_in, t->rcv_nxt);
         while(nxt) {
@@ -1148,7 +1135,7 @@
         t->sock.ev_pending |= PICO_SOCK_EV_RD;
         t->rcv_nxt = SEQN(f) + f->payload_len;
       } else {
-        tcp_dbg("TCP> lo segment. Uninteresting retransmission. (exp: %x got: %x)\n", t->rcv_nxt, SEQN(f));
+        tcp_dbg("TCP> lo segment. Possible retransmission. (exp: %x got: %x)\n", t->rcv_nxt, SEQN(f));
       }
     } else {
       tcp_dbg("TCP> hi segment. Possible packet loss. I'll dupack this. (exp: %x got: %x)\n", t->rcv_nxt, SEQN(f));
@@ -1223,7 +1210,7 @@
     /* Finally, assign a new value for the RTO, as specified in the RFC, with K=4 */
     t->rto = t->avg_rtt + (t->rttvar << 2);
   }
-  tcp_dbg(" -----=============== RTT CUR: %u AVG: %u RTTVAR: %u RTO: %u ======================----\n", rtt, t->avg_rtt, t->rttvar, t->rto);
+  tcp_dbg(" -----=============== RTT AVG: %u RTTVAR: %u RTO: %u ======================----\n", t->avg_rtt, t->rttvar, t->rto);
 }
 
 static void tcp_congestion_control(struct pico_socket_tcp *t)
@@ -1232,8 +1219,6 @@
     return;
   if (t->cwnd > t->tcpq_out.frames) {
     tcp_dbg("Limited by app: %d\n", t->cwnd);
-    if (t->sock.wakeup)
-      t->sock.wakeup(PICO_SOCK_EV_WR, &t->sock);
     return;
   }
   tcp_dbg("Doing congestion control\n");
@@ -1259,7 +1244,7 @@
   if( t->sock.net && ((t->sock.state & 0xFF00) == PICO_SOCKET_STATE_TCP_ESTABLISHED
   		|| (t->sock.state & 0xFF00) == PICO_SOCKET_STATE_TCP_CLOSE_WAIT) )
   {
-		tcp_dbg("TIMEOUT! backoff = %d\n", t->backoff);
+		tcp_dbg("\n\nTIMEOUT! backoff = %d\n", t->backoff);
 		/* was timer cancelled? */
 		if (t->timer_running == 0) {
 			add_retransmission_timer(t, 0);
@@ -1347,7 +1332,7 @@
     tcp_add_options(t, f, 0, f->transport_len - f->payload_len - PICO_SIZE_TCPHDR);
     hdr->rwnd = short_be(t->wnd);
     hdr->flags |= PICO_TCP_PSH;
-    hdr->ack = long_be(t->rcv_nxt);
+    //hdr->ack = long_be(t->rcv_nxt);  /* XXX TODO check: setting ack field with no ACK flag ?? */
     hdr->crc = 0;
     hdr->crc = short_be(pico_tcp_checksum_ipv4(f));
     /* TCP: ENQUEUE to PROTO ( retransmit )*/
@@ -1406,7 +1391,7 @@
     tcp_dbg("%08x %d%s\n", cur, cur_f->payload_len, info);
 
   }
-  tcp_dbg("SND_NXT is %08x, snd_LAST is %08x\n", nxt, t->snd_last);
+  tcp_dbg("SND_NXT is %08x, snd_LAST is %08x", nxt, t->snd_last);
   tcp_dbg("===================================\n");
   tcp_dbg("\n\n");
 }
@@ -1418,7 +1403,7 @@
   struct pico_socket_tcp *t = (struct pico_socket_tcp *)s;
   struct pico_tcp_hdr *hdr = (struct pico_tcp_hdr *) f->transport_hdr;
   uint32_t rtt = 0;
-  uint16_t acked = 0;
+  int acked = 0;
   struct pico_frame *una = NULL;
   if ((hdr->flags & PICO_TCP_ACK) == 0)
     return -1;
@@ -1450,16 +1435,10 @@
     t->backoff = 0;
 
     /* Do rtt/rttvar/rto calculations */
-    /* First, try with timestamps, using the value from options */
-    if(f && (f->timestamp != 0)) {
-      rtt = time_diff(pico_tick, f->timestamp);
+    if(una && (una->timestamp != 0)) {
+      rtt = time_diff(pico_tick, una->timestamp);
       if (rtt)
         tcp_rtt(t, rtt);
-    } else if(una && (una->timestamp != 0)) {
-      /* If no timestamps are there, use conservatve estimation on the una */
-        rtt = time_diff(pico_tick, una->timestamp);
-        if (rtt)
-          tcp_rtt(t, rtt);
     }
 
     tcp_dbg("TCP ACK> FRESH ACK %08x (acked %d) Queue size: %u/%u frames: %u cwnd: %u in_flight: %u snd_una: %u\n", ACKN(f), acked, t->tcpq_out.size, t->tcpq_out.max_size, t->tcpq_out.frames, t->cwnd, t->in_flight, SEQN(una));
@@ -1536,13 +1515,13 @@
   /* if Nagle enabled, check if no unack'ed data and fill out queue (till window) */
   if (IS_NAGLE_ENABLED((&(t->sock)))) {
     while (!IS_TCP_HOLDQ_EMPTY(t) && ((t->tcpq_out.max_size - t->tcpq_out.size) >= PICO_TCP_DEFAULT_MSS)) {
-      tcp_dbg_nagle("TCP_ACK - NAGLE add new segment\n");
+      tcp_dbg("TCP_ACK - NAGLE add new segment\n");
       f_new = pico_hold_segment_make(t);
       if (f_new == NULL)
         break;            /* XXX corrupt !!! (or no memory) */
       if (pico_enqueue_segment(&t->tcpq_out,f_new) <= 0)
         // handle error
-        tcp_dbg_nagle("TCP_ACK - NAGLE FAILED to enqueue in out\n");
+        tcp_dbg("TCP_ACK - NAGLE FAILED to enqueue in out\n");
     }
   }
 
@@ -1560,8 +1539,7 @@
 
 static int tcp_finwaitack(struct pico_socket *s, struct pico_frame *f)
 {
-  tcp_dbg("RECEIVED ACK IN FIN_WAIT1\n");
-  tcp_dbg("TCP> IN STATE FIN_WAIT2\n");
+  tcp_dbg("RECEIVED ACK IN FIN_WAIT1\nTCP> IN STATE FIN_WAIT2\n");
 
   /* acking part */
   tcp_ack(s,f);
@@ -1575,8 +1553,6 @@
 static void tcp_deltcb(unsigned long when, void *arg)
 {
   struct pico_socket_tcp *t = (struct pico_socket_tcp *)arg;
-  IGNORE_PARAMETER(when);
-
   if (TCPSTATE(&t->sock) == PICO_SOCKET_STATE_TCP_TIME_WAIT) {
     tcp_dbg("TCP> state: time_wait, final timer expired, going to closed state\n");
     /* update state */
@@ -1633,7 +1609,6 @@
 
 static int tcp_lastackwait(struct pico_socket *s, struct pico_frame *f)
 {
-	IGNORE_PARAMETER(f);
   tcp_dbg("TCP> state: last_ack, received ack, to closed\n");
   s->state &= 0x00FFU;
   s->state |= PICO_SOCKET_STATE_TCP_CLOSED;
@@ -1668,8 +1643,8 @@
 #endif
 #ifdef PICO_SUPPORT_IPV6
   if (IS_IPV6(f)) {
-    new->sock.remote_addr.ip6 = ((struct pico_ipv6_hdr *)(f->net_hdr))->src;
-    new->sock.local_addr.ip6 = ((struct pico_ipv6_hdr *)(f->net_hdr))->dst;
+    memcpy(new->sock.remote_addr.ip6.addr, ((struct pico_ipv6_hdr *)(f->net_hdr))->src, PICO_SIZE_IP6);
+    memcpy(new->sock.remote_addr.ip6.addr, ((struct pico_ipv6_hdr *)(f->net_hdr))->src, PICO_SIZE_IP6);
   }
 #endif
 
@@ -1785,8 +1760,8 @@
 
     if (s->wakeup){
       if(f->payload_len>0){
-        struct pico_socket_tcp *_t = (struct pico_socket_tcp *)s;
-        _t->sock.ev_pending |=PICO_SOCK_EV_CLOSE;
+        struct pico_socket_tcp *t = (struct pico_socket_tcp *)s;
+        t->sock.ev_pending |=PICO_SOCK_EV_CLOSE;
       }else
         s->wakeup(PICO_SOCK_EV_CLOSE, s);
     }
@@ -1804,7 +1779,6 @@
 static int tcp_rcvfin(struct pico_socket *s, struct pico_frame *f)
 {
   struct pico_socket_tcp *t = (struct pico_socket_tcp *)s;
-  IGNORE_PARAMETER(f);
   tcp_dbg("TCP> Received FIN in FIN_WAIT1\n");
   s->state &= 0x00FFU;
   s->state |= PICO_SOCKET_STATE_TCP_CLOSING;
@@ -1818,8 +1792,6 @@
 static int tcp_finack(struct pico_socket *s, struct pico_frame *f)
 {
   struct pico_socket_tcp *t = (struct pico_socket_tcp *)s;
-  IGNORE_PARAMETER(f);
-
   tcp_dbg("TCP> ENTERED finack\n");
   t->rcv_nxt++;
   /* send ACK */
@@ -1927,9 +1899,9 @@
   { PICO_SOCKET_STATE_TCP_CLOSED,       NULL,            NULL,              NULL,              NULL,            NULL,            NULL,            NULL     },
   { PICO_SOCKET_STATE_TCP_LISTEN,       &tcp_syn,        &tcp_nosync_rst,   &tcp_nosync_rst,   &tcp_nosync_rst, &tcp_nosync_rst, &tcp_nosync_rst, NULL     },
   { PICO_SOCKET_STATE_TCP_SYN_SENT,     &tcp_nosync_rst, &tcp_synack,       &tcp_nosync_rst,   &tcp_nosync_rst, &tcp_nosync_rst, &tcp_nosync_rst, &tcp_rst },
-  { PICO_SOCKET_STATE_TCP_SYN_RECV,     NULL,            &tcp_nosync_rst,   &tcp_first_ack,    &tcp_nosync_rst, &tcp_nosync_rst, &tcp_nosync_rst, &tcp_rst },
+  { PICO_SOCKET_STATE_TCP_SYN_RECV,     &tcp_nosync_rst, &tcp_nosync_rst,   &tcp_first_ack,    &tcp_nosync_rst, &tcp_nosync_rst, &tcp_nosync_rst, &tcp_rst },
   { PICO_SOCKET_STATE_TCP_ESTABLISHED,  NULL,            &tcp_ack,          &tcp_ack,          &tcp_data_in,    &tcp_closewait,  &tcp_closewait,  &tcp_rst },
-  { PICO_SOCKET_STATE_TCP_CLOSE_WAIT,   NULL,            &tcp_ack,          &tcp_ack,          &tcp_send_rst,   &tcp_closewait,  &tcp_closewait,  &tcp_rst },
+  { PICO_SOCKET_STATE_TCP_CLOSE_WAIT,   NULL,            &tcp_ack,          &tcp_ack,          &tcp_send_rst,   &tcp_closewait,  &tcp_closewait,   &tcp_rst },
   { PICO_SOCKET_STATE_TCP_LAST_ACK,     NULL,            &tcp_ack,          &tcp_lastackwait,  &tcp_send_rst,   &tcp_send_rst,   &tcp_send_rst,   &tcp_rst },
   { PICO_SOCKET_STATE_TCP_FIN_WAIT1,    NULL,            &tcp_ack,          &tcp_finwaitack,   &tcp_data_in,    &tcp_rcvfin,     &tcp_finack,     &tcp_rst },
   { PICO_SOCKET_STATE_TCP_FIN_WAIT2,    NULL,            &tcp_ack,          &tcp_ack,          &tcp_data_in,    &tcp_finwaitfin, &tcp_finack,     &tcp_rst },
@@ -1971,7 +1943,7 @@
         action->ack(s,f);
       }
     }
-    if (f->payload_len > 0 && !(s->state & PICO_SOCKET_STATE_CLOSED)) {
+    if (f->payload_len > 0) {
       ret = f->payload_len;
       if (action->data)
         action->data(s,f);
@@ -1998,8 +1970,7 @@
 static void tcp_send_keepalive(unsigned long when, void *_t)
 {
   struct pico_socket_tcp *t = (struct pico_socket_tcp *)_t;
-  IGNORE_PARAMETER(when);
-  tcp_dbg("Sending keepalive (%d), [State = %d]...\n", t->backoff,t->sock.state );
+  tcp_dbg("\n\nSending keepalive (%d), [State = %d]...\n", t->backoff,t->sock.state );
   if( t->sock.net && ((t->sock.state & 0xFF00) == PICO_SOCKET_STATE_TCP_ESTABLISHED) )
   {
 		tcp_send_ack(t);
@@ -2016,26 +1987,6 @@
   }
 }
 
-void zombie_timer(unsigned long time, void *param)
-{
-	struct tcp_port_pair * ports = (struct tcp_port_pair *)param;
-	IGNORE_PARAMETER(time);
-	if(ports)
-	{
-		struct pico_socket_tcp * t = (struct pico_socket_tcp *)pico_sockets_find(ports->local,ports->remote);
-		if(t)
-		{
-			(t->sock).state &= 0x00FFU;
-			(t->sock).state |= PICO_SOCKET_STATE_TCP_CLOSED;
-			(t->sock).state &= 0xFF00U;
-			(t->sock).state |= PICO_SOCKET_STATE_CLOSED;
-			tcp_dbg("Deleting zombie socket %p\n",param);
-			pico_socket_del(&t->sock);
-		}
-		pico_free(ports);
-	}
-}
-
 int pico_tcp_output(struct pico_socket *s, int loop_score)
 {
   struct pico_socket_tcp *t = (struct pico_socket_tcp *)s;
@@ -2057,7 +2008,7 @@
       if (t->x_mode != PICO_TCP_WINDOW_FULL) {
         tcp_dbg("TCP> RIGHT SIZING (rwnd: %d, frame len: %d\n",t->recv_wnd << t->recv_wnd_scale, f->payload_len);
         tcp_dbg("In window full...\n");
-        t->snd_nxt = SEQN(una);   /* XXX prevent out-of-order-packets ! */ /*DLA re-enabled.*/
+        //t->snd_nxt = SEQN(una);   /* XXX prevent out-of-order-packets ! */
         t->snd_retry = SEQN(una);   /* XXX replace by retry pointer? */
 
         /* Alternative to the line above:  (better performance, but seems to lock anyway with larger buffers)
@@ -2089,11 +2040,9 @@
   if (sent > 0) {
     if (t->rto < PICO_TCP_RTO_MIN)
       t->rto = PICO_TCP_RTO_MIN;
-    //if (s->wakeup)
-    //  t->sock.wakeup(PICO_SOCK_EV_WR, &t->sock);
     add_retransmission_timer(t, pico_tick + t->rto);
   } else {
-    /* Nothing to transmit. */
+    // no packets in queue ??
   }
 
   if ((t->tcpq_out.frames == 0) && (s->state & PICO_SOCKET_STATE_SHUT_LOCAL)) {    /* if no more packets in queue, XXX replacled !f by tcpq check */
@@ -2105,17 +2054,12 @@
       s->state &= 0x00FFU;
       s->state |= PICO_SOCKET_STATE_TCP_FIN_WAIT1;
     } else if ((s->state & PICO_SOCKET_STATE_TCP) == PICO_SOCKET_STATE_TCP_CLOSE_WAIT) {
-    	struct tcp_port_pair *pair = (struct tcp_port_pair *)pico_zalloc(sizeof(struct tcp_port_pair));
-    	pair->local = s->local_port;
-    	pair->remote = s->remote_port;
       /* send fin if queue empty and in state shut local (write) */
       tcp_send_fin(t);
       /* change tcp state to LAST_ACK */
       s->state &= 0x00FFU;
       s->state |= PICO_SOCKET_STATE_TCP_LAST_ACK;
       tcp_dbg("TCP> STATE: LAST_ACK.\n");
-      // start zombie timer
-      pico_timer_add(PICO_TCP_ZOMBIE_TO,&zombie_timer,(void *)pair);
     }
   }
   return loop_score;
@@ -2174,7 +2118,7 @@
 
   hdr->len = (f_new->payload - f_new->transport_hdr) << 2 | t->jumbo;
 
-  tcp_dbg_nagle("NAGLE make - joined %d segments, len %d bytes\n",test,total_payload_len);
+  tcp_dbg("NAGLE make - joined %d segments, len %d bytes\n",test,total_payload_len);
 
   return f_new;
 }
@@ -2187,14 +2131,13 @@
   struct pico_socket_tcp *t = (struct pico_socket_tcp *) f->sock;
   struct pico_frame *f_new;
   int total_len = 0;
-  IGNORE_PARAMETER(self);
-  pico_err = PICO_ERR_NOERR;
+
   hdr->trans.sport = t->sock.local_port;
   hdr->trans.dport = t->sock.remote_port;
   hdr->seq = long_be(t->snd_last + 1);
   hdr->len = (f->payload - f->transport_hdr) << 2 | t->jumbo;
 
-  if ((uint32_t)f->payload_len > (uint32_t)(t->tcpq_out.max_size - t->tcpq_out.size))
+  if (f->payload_len > (t->tcpq_out.max_size - t->tcpq_out.size))
     t->sock.ev_pending &= (~PICO_SOCK_EV_WR);
 
   /***************************************************************************/
@@ -2202,7 +2145,7 @@
   if (!IS_NAGLE_ENABLED((&(t->sock)))) {
     /* TCP_NODELAY enabled, original behavior */
     if (pico_enqueue_segment(&t->tcpq_out,f) > 0) {
-      tcp_dbg_nagle("TCP_PUSH - NO NAGLE - Pushing segment %08x, len %08x to socket %p\n", t->snd_last + 1, f->payload_len, t);
+      tcp_dbg("TCP_PUSH - NO NAGLE - Pushing segment %08x, len %08x to socket %p\n", t->snd_last + 1, f->payload_len, t);
       t->snd_last += f->payload_len;
       return f->payload_len;
     } else {
@@ -2215,7 +2158,7 @@
     /* Nagle's algorithm enabled, check if ready to send, or put frame in hold queue */
     if (IS_TCP_IDLE(t) && IS_TCP_HOLDQ_EMPTY(t)) {  /* opt 1. send frame */
       if (pico_enqueue_segment(&t->tcpq_out,f) > 0) {
-        tcp_dbg_nagle("TCP_PUSH - NAGLE - Pushing segment %08x, len %08x to socket %p\n", t->snd_last + 1, f->payload_len, t);
+        tcp_dbg("TCP_PUSH - NAGLE - Pushing segment %08x, len %08x to socket %p\n", t->snd_last + 1, f->payload_len, t);
         t->snd_last += f->payload_len;
         return f->payload_len;
       } else {
@@ -2228,29 +2171,28 @@
         /* IF enough data in hold (>mss) AND space in out queue (>mss) */
         /* add current frame in hold and make new segment */
         if (pico_enqueue_segment(&t->tcpq_hold,f) > 0 ) {
-          tcp_dbg_nagle("TCP_PUSH - NAGLE - Pushed into hold, make new (enqueued frames out %d)\n",t->tcpq_out.frames);
+          tcp_dbg("TCP_PUSH - NAGLE - Pushed into hold, make new (enqueued frames out %d)\n",t->tcpq_out.frames);
           t->snd_last += f->payload_len;    /* XXX  WATCH OUT */
           f_new = pico_hold_segment_make(t);
         } else {
-          tcp_dbg_nagle("TCP_PUSH - NAGLE - enqueue hold failed 1\n");
+          tcp_dbg("TCP_PUSH - NAGLE - enqueue hold failed 1\n");
           return 0;
         }
         /* and put new frame in out queue */
         if ((f_new != NULL) && (pico_enqueue_segment(&t->tcpq_out,f_new) > 0)) {
           return f_new->payload_len;
         } else {
-          tcp_dbg_nagle("TCP_PUSH - NAGLE - enqueue out failed, f_new = %p\n",f_new);
+          tcp_dbg("TCP_PUSH - NAGLE - enqueue out failed, f_new = %p\n",f_new);
           return -1;                        /* XXX something seriously wrong */
         }
       } else {
         /* ELSE put frame in hold queue */
         if (pico_enqueue_segment(&t->tcpq_hold,f) > 0) {
-          tcp_dbg_nagle("TCP_PUSH - NAGLE - Pushed into hold (enqueued frames out %d)\n",t->tcpq_out.frames);
+          tcp_dbg("TCP_PUSH - NAGLE - Pushed into hold (enqueued frames out %d)\n",t->tcpq_out.frames);
           t->snd_last += f->payload_len;    /* XXX  WATCH OUT */
           return f->payload_len;
         } else {
-          pico_err = PICO_ERR_EAGAIN;
-          tcp_dbg_nagle("TCP_PUSH - NAGLE - enqueue hold failed 2\n");
+          tcp_dbg("TCP_PUSH - NAGLE - enqueue hold failed 2\n");
           return 0;
         }
       }