X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Ftcp%2Ftcp.c;h=ea350dddc69c6ad10bdcd090948acc27dff68537;hb=7ac053b27fee8f9e437cf7b61357943356381061;hp=f457ef7e53661f180394e878fffa8185cf46a17f;hpb=7fe51f3e3e80ed6ffe989df1c6963527166afc25;p=vpp.git

diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c
index f457ef7e536..ea350dddc69 100644
--- a/src/vnet/tcp/tcp.c
+++ b/src/vnet/tcp/tcp.c
@@ -28,31 +28,72 @@
 
 tcp_main_t tcp_main;
 
+typedef struct
+{
+  fib_protocol_t nh_proto;
+  vnet_link_t link_type;
+  ip46_address_t ip;
+  u32 sw_if_index;
+  u8 is_add;
+} tcp_add_del_adj_args_t;
+
+static void
+tcp_add_del_adj_cb (tcp_add_del_adj_args_t * args)
+{
+  u32 ai;
+  if (args->is_add)
+    {
+      adj_nbr_add_or_lock (args->nh_proto, args->link_type, &args->ip,
+			   args->sw_if_index);
+    }
+  else
+    {
+      ai = adj_nbr_find (FIB_PROTOCOL_IP6, VNET_LINK_IP6, &args->ip,
+			 args->sw_if_index);
+      if (ai != ADJ_INDEX_INVALID)
+	adj_unlock (ai);
+    }
+}
+
+static void
+tcp_add_del_adjacency (tcp_connection_t * tc, u8 is_add)
+{
+  tcp_add_del_adj_args_t args = {
+    .nh_proto = FIB_PROTOCOL_IP6,
+    .link_type = VNET_LINK_IP6,
+    .ip = tc->c_rmt_ip,
+    .sw_if_index = tc->sw_if_index,
+    .is_add = is_add
+  };
+  vlib_rpc_call_main_thread (tcp_add_del_adj_cb, (u8 *) & args,
+			     sizeof (args));
+}
+
 static u32
 tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl)
 {
   tcp_main_t *tm = &tcp_main;
   tcp_connection_t *listener;
+  void *iface_ip;
 
   pool_get (tm->listener_pool, listener);
-  memset (listener, 0, sizeof (*listener));
+  clib_memset (listener, 0, sizeof (*listener));
 
   listener->c_c_index = listener - tm->listener_pool;
-  listener->c_lcl_port = clib_host_to_net_u16 (lcl->port);
+  listener->c_lcl_port = lcl->port;
 
-  if (lcl->is_ip4)
+  /* If we are provided a sw_if_index, bind using one of its ips */
+  if (ip_is_zero (&lcl->ip, 1) && lcl->sw_if_index != ENDPOINT_INVALID_INDEX)
     {
-      listener->c_lcl_ip4.as_u32 = lcl->ip.ip4.as_u32;
-      listener->c_is_ip4 = 1;
+      if ((iface_ip = ip_interface_get_first_ip (lcl->sw_if_index,
+						 lcl->is_ip4)))
+	ip_set (&lcl->ip, iface_ip, lcl->is_ip4);
     }
-  else
-    {
-      clib_memcpy (&listener->c_lcl_ip6, &lcl->ip.ip6,
-		   sizeof (ip6_address_t));
-
-    }
-  listener->c_transport_proto = TRANSPORT_PROTO_TCP;
+  ip_copy (&listener->c_lcl_ip, &lcl->ip, lcl->is_ip4);
+  listener->c_is_ip4 = lcl->is_ip4;
+  listener->c_proto = TRANSPORT_PROTO_TCP;
   listener->c_s_index = session_index;
+  listener->c_fib_index = lcl->fib_index;
   listener->state = TCP_STATE_LISTEN;
 
   tcp_connection_timers_init (listener);
@@ -62,7 +103,7 @@ tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl)
   return listener->c_c_index;
 }
 
-u32
+static u32
 tcp_session_bind (u32 session_index, transport_endpoint_t * tep)
 {
   return tcp_connection_bind (session_index, tep);
@@ -80,19 +121,19 @@ tcp_connection_unbind (u32 listener_index)
 
   /* Poison the entry */
   if (CLIB_DEBUG > 0)
-    memset (tc, 0xFA, sizeof (*tc));
+    clib_memset (tc, 0xFA, sizeof (*tc));
 
   pool_put_index (tm->listener_pool, listener_index);
 }
 
-u32
+static u32
 tcp_session_unbind (u32 listener_index)
 {
   tcp_connection_unbind (listener_index);
   return 0;
 }
 
-transport_connection_t *
+static transport_connection_t *
 tcp_session_get_listener (u32 listener_index)
 {
   tcp_main_t *tm = vnet_get_tcp_main ();
@@ -101,36 +142,18 @@ tcp_session_get_listener (u32 listener_index)
   return &tc->connection;
 }
 
-always_inline void
-transport_endpoint_del (u32 tepi)
-{
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  clib_spinlock_lock_if_init (&tm->local_endpoints_lock);
-  pool_put_index (tm->local_endpoints, tepi);
-  clib_spinlock_unlock_if_init (&tm->local_endpoints_lock);
-}
-
-always_inline transport_endpoint_t *
-transport_endpoint_new (void)
-{
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  transport_endpoint_t *tep;
-  pool_get (tm->local_endpoints, tep);
-  return tep;
-}
-
 /**
  * Cleanup half-open connection
  *
  */
-void
+static void
 tcp_half_open_connection_del (tcp_connection_t * tc)
 {
   tcp_main_t *tm = vnet_get_tcp_main ();
   clib_spinlock_lock_if_init (&tm->half_open_lock);
   pool_put_index (tm->half_open_connections, tc->c_c_index);
   if (CLIB_DEBUG)
-    memset (tc, 0xFA, sizeof (*tc));
+    clib_memset (tc, 0xFA, sizeof (*tc));
   clib_spinlock_unlock_if_init (&tm->half_open_lock);
 }
 
@@ -155,14 +178,14 @@ tcp_half_open_connection_cleanup (tcp_connection_t * tc)
   return 0;
 }
 
-tcp_connection_t *
+static tcp_connection_t *
 tcp_half_open_connection_new (void)
 {
   tcp_main_t *tm = vnet_get_tcp_main ();
   tcp_connection_t *tc = 0;
   ASSERT (vlib_get_thread_index () == 0);
   pool_get (tm->half_open_connections, tc);
-  memset (tc, 0, sizeof (*tc));
+  clib_memset (tc, 0, sizeof (*tc));
   tc->c_c_index = tc - tm->half_open_connections;
   return tc;
 }
@@ -176,18 +199,10 @@ void
 tcp_connection_cleanup (tcp_connection_t * tc)
 {
   tcp_main_t *tm = &tcp_main;
-  u32 tepi;
-  transport_endpoint_t *tep;
 
   /* Cleanup local endpoint if this was an active connect */
-  tepi = transport_endpoint_lookup (&tm->local_endpoints_table, &tc->c_lcl_ip,
-				    clib_net_to_host_u16 (tc->c_lcl_port));
-  if (tepi != TRANSPORT_ENDPOINT_INVALID_INDEX)
-    {
-      tep = pool_elt_at_index (tm->local_endpoints, tepi);
-      transport_endpoint_table_del (&tm->local_endpoints_table, tep);
-      transport_endpoint_del (tepi);
-    }
+  transport_endpoint_cleanup (TRANSPORT_PROTO_TCP, &tc->c_lcl_ip,
+			      tc->c_lcl_port);
 
   /* Check if connection is not yet fully established */
   if (tc->state == TCP_STATE_SYN_SENT)
@@ -195,7 +210,8 @@ tcp_connection_cleanup (tcp_connection_t * tc)
       /* Try to remove the half-open connection. If this is not the owning
        * thread, tc won't be removed. Retransmit or establish timers will
        * eventually expire and call again cleanup on the right thread. */
-      tcp_half_open_connection_cleanup (tc);
+      if (tcp_half_open_connection_cleanup (tc))
+	tc->flags |= TCP_CONN_HALF_OPEN_DONE;
     }
   else
     {
@@ -204,9 +220,12 @@ tcp_connection_cleanup (tcp_connection_t * tc)
       /* Make sure all timers are cleared */
       tcp_connection_timers_reset (tc);
 
+      if (!tc->c_is_ip4 && ip6_address_is_link_local_unicast (&tc->c_rmt_ip6))
+	tcp_add_del_adjacency (tc, 0);
+
       /* Poison the entry */
       if (CLIB_DEBUG > 0)
-	memset (tc, 0xFA, sizeof (*tc));
+	clib_memset (tc, 0xFA, sizeof (*tc));
       pool_put (tm->connections[thread_index], tc);
     }
 }
@@ -233,7 +252,7 @@ tcp_connection_new (u8 thread_index)
   tcp_connection_t *tc;
 
   pool_get (tm->connections[thread_index], tc);
-  memset (tc, 0, sizeof (*tc));
+  clib_memset (tc, 0, sizeof (*tc));
   tc->c_c_index = tc - tm->connections[thread_index];
   tc->c_thread_index = thread_index;
   return tc;
@@ -255,22 +274,23 @@ tcp_connection_reset (tcp_connection_t * tc)
       tcp_connection_cleanup (tc);
       break;
     case TCP_STATE_SYN_SENT:
-      stream_session_connect_notify (&tc->connection, 1 /* fail */ );
+      session_stream_connect_notify (&tc->connection, 1 /* fail */ );
       tcp_connection_cleanup (tc);
       break;
     case TCP_STATE_ESTABLISHED:
+      tcp_connection_timers_reset (tc);
+      /* Set the cleanup timer, in case the session layer/app don't
+       * cleanly close the connection */
+      tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
+      stream_session_reset_notify (&tc->connection);
+      break;
     case TCP_STATE_CLOSE_WAIT:
     case TCP_STATE_FIN_WAIT_1:
     case TCP_STATE_FIN_WAIT_2:
     case TCP_STATE_CLOSING:
       tc->state = TCP_STATE_CLOSED;
       TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc);
-
-      /* Make sure all timers are cleared */
       tcp_connection_timers_reset (tc);
-      stream_session_reset_notify (&tc->connection);
-
-      /* Wait for cleanup from session layer but not forever */
       tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
       break;
     case TCP_STATE_CLOSED:
@@ -303,35 +323,45 @@ tcp_connection_close (tcp_connection_t * tc)
       tc->state = TCP_STATE_CLOSED;
       break;
     case TCP_STATE_SYN_RCVD:
+      tcp_connection_timers_reset (tc);
       tcp_send_fin (tc);
       tc->state = TCP_STATE_FIN_WAIT_1;
+      tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
       break;
     case TCP_STATE_ESTABLISHED:
-      if (!stream_session_tx_fifo_max_dequeue (&tc->connection))
+      if (!session_tx_fifo_max_dequeue (&tc->connection))
 	tcp_send_fin (tc);
       else
 	tc->flags |= TCP_CONN_FINPNDG;
       tc->state = TCP_STATE_FIN_WAIT_1;
       break;
     case TCP_STATE_CLOSE_WAIT:
-      tcp_send_fin (tc);
-      tc->state = TCP_STATE_LAST_ACK;
+      if (!session_tx_fifo_max_dequeue (&tc->connection))
+	{
+	  tcp_send_fin (tc);
+	  tcp_connection_timers_reset (tc);
+	  tc->state = TCP_STATE_LAST_ACK;
+	  tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
+	}
+      else
+	tc->flags |= TCP_CONN_FINPNDG;
       break;
     case TCP_STATE_FIN_WAIT_1:
+      tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
       break;
     default:
-      clib_warning ("state: %u", tc->state);
+      TCP_DBG ("state: %u", tc->state);
     }
 
   TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc);
 
   /* If in CLOSED and WAITCLOSE timer is not set, delete connection now */
-  if (tc->timers[TCP_TIMER_WAITCLOSE] == TCP_TIMER_HANDLE_INVALID
+  if (!tcp_timer_is_active (tc, TCP_TIMER_WAITCLOSE)
       && tc->state == TCP_STATE_CLOSED)
     tcp_connection_del (tc);
 }
 
-void
+static void
 tcp_session_close (u32 conn_index, u32 thread_index)
 {
   tcp_connection_t *tc;
@@ -339,100 +369,15 @@ tcp_session_close (u32 conn_index, u32 thread_index)
   tcp_connection_close (tc);
 }
 
-void
+static void
 tcp_session_cleanup (u32 conn_index, u32 thread_index)
 {
   tcp_connection_t *tc;
   tc = tcp_connection_get (conn_index, thread_index);
-
-  /* Wait for the session tx events to clear */
+  tcp_connection_timers_reset (tc);
   tc->state = TCP_STATE_CLOSED;
   TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc);
-  tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
-}
-
-void *
-ip_interface_get_first_ip (u32 sw_if_index, u8 is_ip4)
-{
-  ip_lookup_main_t *lm4 = &ip4_main.lookup_main;
-  ip_lookup_main_t *lm6 = &ip6_main.lookup_main;
-  ip_interface_address_t *ia = 0;
-
-  if (is_ip4)
-    {
-      /* *INDENT-OFF* */
-      foreach_ip_interface_address (lm4, ia, sw_if_index, 1 /* unnumbered */ ,
-      ({
-        return ip_interface_address_get_address (lm4, ia);
-      }));
-      /* *INDENT-ON* */
-    }
-  else
-    {
-      /* *INDENT-OFF* */
-      foreach_ip_interface_address (lm6, ia, sw_if_index, 1 /* unnumbered */ ,
-      ({
-        ip6_address_t *rv;
-        rv = ip_interface_address_get_address (lm6, ia);
-        /* Trying to use a link-local ip6 src address is a fool's errand */
-        if (!ip6_address_is_link_local_unicast (rv))
-          return rv;
-      }));
-      /* *INDENT-ON* */
-    }
-
-  return 0;
-}
-
-#define PORT_MASK ((1 << 16)- 1)
-/**
- * Allocate local port and add if successful add entry to local endpoint
- * table to mark the pair as used.
- */
-int
-tcp_allocate_local_port (ip46_address_t * ip)
-{
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  transport_endpoint_t *tep;
-  u32 tei;
-  u16 min = 1024, max = 65535;	/* XXX configurable ? */
-  int tries, limit;
-
-  limit = max - min;
-
-  /* Only support active opens from thread 0 */
-  ASSERT (vlib_get_thread_index () == 0);
-
-  /* Search for first free slot */
-  for (tries = 0; tries < limit; tries++)
-    {
-      u16 port = 0;
-
-      /* Find a port in the specified range */
-      while (1)
-	{
-	  port = random_u32 (&tm->port_allocator_seed) & PORT_MASK;
-	  if (PREDICT_TRUE (port >= min && port < max))
-	    break;
-	}
-
-      /* Look it up */
-      tei = transport_endpoint_lookup (&tm->local_endpoints_table, ip, port);
-      /* If not found, we're done */
-      if (tei == TRANSPORT_ENDPOINT_INVALID_INDEX)
-	{
-	  clib_spinlock_lock_if_init (&tm->local_endpoints_lock);
-	  tep = transport_endpoint_new ();
-	  clib_memcpy (&tep->ip, ip, sizeof (*ip));
-	  tep->port = port;
-	  transport_endpoint_table_add (&tm->local_endpoints_table, tep,
-					tep - tm->local_endpoints);
-	  clib_spinlock_unlock_if_init (&tm->local_endpoints_lock);
-
-	  return tep->port;
-	}
-    }
-  return -1;
+  tcp_connection_cleanup (tc);
 }
 
 /**
@@ -490,7 +435,7 @@ tcp_connection_select_lb_bucket (tcp_connection_t * tc, const dpo_id_t * dpo,
   if (tc->c_is_ip4)
     {
       ip4_tcp_hdr_t hdr;
-      memset (&hdr, 0, sizeof (hdr));
+      clib_memset (&hdr, 0, sizeof (hdr));
       hdr.ip.protocol = IP_PROTOCOL_TCP;
       hdr.ip.address_pair.src.as_u32 = tc->c_lcl_ip.ip4.as_u32;
       hdr.ip.address_pair.dst.as_u32 = tc->c_rmt_ip.ip4.as_u32;
@@ -501,7 +446,7 @@ tcp_connection_select_lb_bucket (tcp_connection_t * tc, const dpo_id_t * dpo,
   else
     {
       ip6_tcp_hdr_t hdr;
-      memset (&hdr, 0, sizeof (hdr));
+      clib_memset (&hdr, 0, sizeof (hdr));
       hdr.ip.protocol = IP_PROTOCOL_TCP;
       clib_memcpy (&hdr.ip.src_address, &tc->c_lcl_ip.ip6,
 		   sizeof (ip6_address_t));
@@ -524,7 +469,7 @@ tcp_lookup_rmt_in_fib (tcp_connection_t * tc)
   clib_memcpy (&prefix.fp_addr, &tc->c_rmt_ip, sizeof (prefix.fp_addr));
   prefix.fp_proto = tc->c_is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
   prefix.fp_len = tc->c_is_ip4 ? 32 : 128;
-  fib_index = fib_table_find (prefix.fp_proto, tc->c_vrf);
+  fib_index = fib_table_find (prefix.fp_proto, tc->c_fib_index);
   return fib_table_lookup (fib_index, &prefix);
 }
 
@@ -562,6 +507,31 @@ tcp_connection_fib_attach (tcp_connection_t * tc)
 }
 #endif /* 0 */
 
+static void
+tcp_cc_init (tcp_connection_t * tc)
+{
+  tc->cc_algo = tcp_cc_algo_get (TCP_CC_NEWRENO);
+  tc->cc_algo->init (tc);
+}
+
+void
+tcp_cc_algo_register (tcp_cc_algorithm_type_e type,
+		      const tcp_cc_algorithm_t * vft)
+{
+  tcp_main_t *tm = vnet_get_tcp_main ();
+  vec_validate (tm->cc_algos, type);
+
+  tm->cc_algos[type] = *vft;
+}
+
+tcp_cc_algorithm_t *
+tcp_cc_algo_get (tcp_cc_algorithm_type_e type)
+{
+  tcp_main_t *tm = vnet_get_tcp_main ();
+  return &tm->cc_algos[type];
+}
+
+
 /**
  * Initialize connection send variables.
  */
@@ -570,14 +540,32 @@ tcp_init_snd_vars (tcp_connection_t * tc)
 {
   u32 time_now;
 
-  /* Set random initial sequence */
+  /*
+   * We use the time to randomize iss and for setting up the initial
+   * timestamp. Make sure it's updated otherwise syn and ack in the
+   * handshake may make it look as if time has flown in the opposite
+   * direction for us.
+   */
+  tcp_set_time_now (tcp_get_worker (vlib_get_thread_index ()));
   time_now = tcp_time_now ();
+
   tc->iss = random_u32 (&time_now);
   tc->snd_una = tc->iss;
   tc->snd_nxt = tc->iss + 1;
   tc->snd_una_max = tc->snd_nxt;
 }
 
+void
+tcp_enable_pacing (tcp_connection_t * tc)
+{
+  u32 initial_bucket, byte_rate;
+  initial_bucket = 16 * tc->snd_mss;
+  byte_rate = 2 << 16;
+  transport_connection_tx_pacer_init (&tc->connection, byte_rate,
+				      initial_bucket);
+  tc->mrtt_us = (u32) ~ 0;
+}
+
 /** Initialize tcp connection variables
  *
  * Should be called after having received a msg from the peer, i.e., a SYN or
@@ -592,120 +580,81 @@ tcp_connection_init_vars (tcp_connection_t * tc)
   if (tc->state == TCP_STATE_SYN_RCVD)
     tcp_init_snd_vars (tc);
 
-  //  tcp_connection_fib_attach (tc);
-}
+  if (!tc->c_is_ip4 && ip6_address_is_link_local_unicast (&tc->c_rmt_ip6))
+    tcp_add_del_adjacency (tc, 1);
 
-int
-tcp_connection_open (transport_endpoint_t * rmt)
-{
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  tcp_connection_t *tc;
-  fib_prefix_t prefix;
-  fib_node_index_t fei;
-  u32 sw_if_index, fib_index;
-  ip46_address_t lcl_addr;
-  int lcl_port;
-
-  /*
-   * Find the local address and allocate port
-   */
-  memset (&lcl_addr, 0, sizeof (lcl_addr));
+  /*  tcp_connection_fib_attach (tc); */
 
-  /* Find a FIB path to the destination */
-  clib_memcpy (&prefix.fp_addr, &rmt->ip, sizeof (rmt->ip));
-  prefix.fp_proto = rmt->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
-  prefix.fp_len = rmt->is_ip4 ? 32 : 128;
+  if (transport_connection_is_tx_paced (&tc->connection)
+      || tcp_main.tx_pacing)
+    tcp_enable_pacing (tc);
+}
 
-  fib_index = fib_table_find (prefix.fp_proto, rmt->vrf);
-  if (fib_index == (u32) ~ 0)
+static int
+tcp_alloc_custom_local_endpoint (tcp_main_t * tm, ip46_address_t * lcl_addr,
+				 u16 * lcl_port, u8 is_ip4)
+{
+  int index, port;
+  if (is_ip4)
     {
-      clib_warning ("no fib table");
-      return -1;
+      index = tm->last_v4_address_rotor++;
+      if (tm->last_v4_address_rotor >= vec_len (tm->ip4_src_addresses))
+	tm->last_v4_address_rotor = 0;
+      lcl_addr->ip4.as_u32 = tm->ip4_src_addresses[index].as_u32;
     }
-
-  fei = fib_table_lookup (fib_index, &prefix);
-
-  /* Couldn't find route to destination. Bail out. */
-  if (fei == FIB_NODE_INDEX_INVALID)
+  else
     {
-      clib_warning ("no route to destination");
-      return -1;
+      index = tm->last_v6_address_rotor++;
+      if (tm->last_v6_address_rotor >= vec_len (tm->ip6_src_addresses))
+	tm->last_v6_address_rotor = 0;
+      clib_memcpy (&lcl_addr->ip6, &tm->ip6_src_addresses[index],
+		   sizeof (ip6_address_t));
     }
-
-  sw_if_index = fib_entry_get_resolving_interface (fei);
-
-  if (sw_if_index == (u32) ~ 0)
+  port = transport_alloc_local_port (TRANSPORT_PROTO_TCP, lcl_addr);
+  if (port < 1)
     {
-      clib_warning ("no resolving interface for %U", format_ip46_address,
-		    &rmt->ip, IP46_TYPE_IP4);
+      clib_warning ("Failed to allocate src port");
       return -1;
     }
+  *lcl_port = port;
+  return 0;
+}
 
-  if (rmt->is_ip4)
-    {
-      ip4_address_t *ip4;
-      int index;
-      if (vec_len (tm->ip4_src_addresses))
-	{
-	  index = tm->last_v4_address_rotor++;
-	  if (tm->last_v4_address_rotor >= vec_len (tm->ip4_src_addresses))
-	    tm->last_v4_address_rotor = 0;
-	  lcl_addr.ip4.as_u32 = tm->ip4_src_addresses[index].as_u32;
-	}
-      else
-	{
-	  ip4 = ip_interface_get_first_ip (sw_if_index, 1);
-	  lcl_addr.ip4.as_u32 = ip4->as_u32;
-	}
-    }
-  else
-    {
-      ip6_address_t *ip6;
-      int index;
-
-      if (vec_len (tm->ip6_src_addresses))
-	{
-	  index = tm->last_v6_address_rotor++;
-	  if (tm->last_v6_address_rotor >= vec_len (tm->ip6_src_addresses))
-	    tm->last_v6_address_rotor = 0;
-	  clib_memcpy (&lcl_addr.ip6, &tm->ip6_src_addresses[index],
-		       sizeof (*ip6));
-	}
-      else
-	{
-	  ip6 = ip_interface_get_first_ip (sw_if_index, 0);
-	  if (ip6 == 0)
-	    {
-	      clib_warning ("no routable ip6 addresses on %U",
-			    format_vnet_sw_if_index_name, vnet_get_main (),
-			    sw_if_index);
-	      return -1;
-	    }
+static int
+tcp_session_open (transport_endpoint_cfg_t * rmt)
+{
+  tcp_main_t *tm = vnet_get_tcp_main ();
+  tcp_connection_t *tc;
+  ip46_address_t lcl_addr;
+  u16 lcl_port;
+  int rv;
 
-	  clib_memcpy (&lcl_addr.ip6, ip6, sizeof (*ip6));
-	}
-    }
+  /*
+   * Allocate local endpoint
+   */
+  if ((rmt->is_ip4 && vec_len (tm->ip4_src_addresses))
+      || (!rmt->is_ip4 && vec_len (tm->ip6_src_addresses)))
+    rv = tcp_alloc_custom_local_endpoint (tm, &lcl_addr, &lcl_port,
+					  rmt->is_ip4);
+  else
+    rv = transport_alloc_local_endpoint (TRANSPORT_PROTO_TCP,
+					 rmt, &lcl_addr, &lcl_port);
 
-  /* Allocate source port */
-  lcl_port = tcp_allocate_local_port (&lcl_addr);
-  if (lcl_port < 1)
-    {
-      clib_warning ("Failed to allocate src port");
-      return -1;
-    }
+  if (rv)
+    return -1;
 
   /*
    * Create connection and send SYN
    */
   clib_spinlock_lock_if_init (&tm->half_open_lock);
   tc = tcp_half_open_connection_new ();
-  clib_memcpy (&tc->c_rmt_ip, &rmt->ip, sizeof (ip46_address_t));
-  clib_memcpy (&tc->c_lcl_ip, &lcl_addr, sizeof (ip46_address_t));
-  tc->c_rmt_port = clib_host_to_net_u16 (rmt->port);
+  ip_copy (&tc->c_rmt_ip, &rmt->ip, rmt->is_ip4);
+  ip_copy (&tc->c_lcl_ip, &lcl_addr, rmt->is_ip4);
+  tc->c_rmt_port = rmt->port;
   tc->c_lcl_port = clib_host_to_net_u16 (lcl_port);
   tc->c_is_ip4 = rmt->is_ip4;
-  tc->c_transport_proto = TRANSPORT_PROTO_TCP;
-  tc->c_vrf = rmt->vrf;
+  tc->c_proto = TRANSPORT_PROTO_TCP;
+  tc->c_fib_index = rmt->fib_index;
   /* The other connection vars will be initialized after SYN ACK */
   tcp_connection_timers_init (tc);
 
@@ -718,12 +667,6 @@ tcp_connection_open (transport_endpoint_t * rmt)
   return tc->c_c_index;
 }
 
-int
-tcp_session_open (transport_endpoint_t * tep)
-{
-  return tcp_connection_open (tep);
-}
-
 const char *tcp_dbg_evt_str[] = {
 #define _(sym, str) str,
   foreach_tcp_dbg_evt
@@ -748,13 +691,38 @@ format_tcp_state (u8 * s, va_list * args)
   return s;
 }
 
+const char *tcp_connection_flags_str[] = {
+#define _(sym, str) str,
+  foreach_tcp_connection_flag
+#undef _
+};
+
+static u8 *
+format_tcp_connection_flags (u8 * s, va_list * args)
+{
+  tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
+  int i, last = -1;
+
+  for (i = 0; i < TCP_CONN_N_FLAG_BITS; i++)
+    if (tc->flags & (1 << i))
+      last = i;
+  for (i = 0; i < last; i++)
+    {
+      if (tc->flags & (1 << i))
+	s = format (s, "%s, ", tcp_connection_flags_str[i]);
+    }
+  if (last >= 0)
+    s = format (s, "%s", tcp_connection_flags_str[last]);
+  return s;
+}
+
 const char *tcp_conn_timers[] = {
 #define _(sym, str) str,
   foreach_tcp_timer
 #undef _
 };
 
-u8 *
+static u8 *
 format_tcp_timers (u8 * s, va_list * args)
 {
   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
@@ -764,7 +732,6 @@ format_tcp_timers (u8 * s, va_list * args)
     if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID)
       last = i;
 
-  s = format (s, "[");
   for (i = 0; i < last; i++)
     {
       if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID)
@@ -772,14 +739,12 @@ format_tcp_timers (u8 * s, va_list * args)
     }
 
   if (last >= 0)
-    s = format (s, "%s]", tcp_conn_timers[i]);
-  else
-    s = format (s, "]");
+    s = format (s, "%s", tcp_conn_timers[i]);
 
   return s;
 }
 
-u8 *
+static u8 *
 format_tcp_congestion_status (u8 * s, va_list * args)
 {
   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
@@ -792,44 +757,68 @@ format_tcp_congestion_status (u8 * s, va_list * args)
   return s;
 }
 
-u8 *
+static i32
+tcp_rcv_wnd_available (tcp_connection_t * tc)
+{
+  return (i32) tc->rcv_wnd - (tc->rcv_nxt - tc->rcv_las);
+}
+
+static u8 *
+format_tcp_congestion (u8 * s, va_list * args)
+{
+  tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
+  u32 indent = format_get_indent (s);
+
+  s = format (s, "%U ", format_tcp_congestion_status, tc);
+  s = format (s, "cwnd %u ssthresh %u rtx_bytes %u bytes_acked %u\n",
+	      tc->cwnd, tc->ssthresh, tc->snd_rxt_bytes, tc->bytes_acked);
+  s = format (s, "%Ucc space %u prev_ssthresh %u snd_congestion %u"
+	      " dupack %u\n", format_white_space, indent,
+	      tcp_available_cc_snd_space (tc), tc->prev_ssthresh,
+	      tc->snd_congestion - tc->iss, tc->rcv_dupacks);
+  s = format (s, "%Utsecr %u tsecr_last_ack %u limited_transmit %u\n",
+	      format_white_space, indent, tc->rcv_opts.tsecr,
+	      tc->tsecr_last_ack, tc->limited_transmit - tc->iss);
+  return s;
+}
+
+static u8 *
 format_tcp_vars (u8 * s, va_list * args)
 {
   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
+  s = format (s, " index: %u flags: %U timers: %U\n", tc->c_c_index,
+	      format_tcp_connection_flags, tc, format_tcp_timers, tc);
   s = format (s, " snd_una %u snd_nxt %u snd_una_max %u",
 	      tc->snd_una - tc->iss, tc->snd_nxt - tc->iss,
 	      tc->snd_una_max - tc->iss);
   s = format (s, " rcv_nxt %u rcv_las %u\n",
 	      tc->rcv_nxt - tc->irs, tc->rcv_las - tc->irs);
-  s = format (s, " snd_wnd %u rcv_wnd %u snd_wl1 %u snd_wl2 %u\n",
-	      tc->snd_wnd, tc->rcv_wnd, tc->snd_wl1 - tc->irs,
+  s = format (s, " snd_wnd %u rcv_wnd %u rcv_wscale %u ",
+	      tc->snd_wnd, tc->rcv_wnd, tc->rcv_wscale);
+  s = format (s, "snd_wl1 %u snd_wl2 %u\n", tc->snd_wl1 - tc->irs,
 	      tc->snd_wl2 - tc->iss);
-  s = format (s, " flight size %u send space %u rcv_wnd_av %d\n",
+  s = format (s, " flight size %u out space %u rcv_wnd_av %u\n",
 	      tcp_flight_size (tc), tcp_available_output_snd_space (tc),
 	      tcp_rcv_wnd_available (tc));
-  s = format (s, " cong %U ", format_tcp_congestion_status, tc);
-  s = format (s, "cwnd %u ssthresh %u rtx_bytes %u bytes_acked %u\n",
-	      tc->cwnd, tc->ssthresh, tc->snd_rxt_bytes, tc->bytes_acked);
-  s = format (s, " prev_ssthresh %u snd_congestion %u dupack %u",
-	      tc->prev_ssthresh, tc->snd_congestion - tc->iss,
-	      tc->rcv_dupacks);
-  s = format (s, " limited_transmit %u\n", tc->limited_transmit - tc->iss);
-  s = format (s, " tsecr %u tsecr_last_ack %u\n", tc->rcv_opts.tsecr,
-	      tc->tsecr_last_ack);
-  s = format (s, " rto %u rto_boff %u srtt %u rttvar %u rtt_ts %u ", tc->rto,
-	      tc->rto_boff, tc->srtt, tc->rttvar, tc->rtt_ts);
-  s = format (s, "rtt_seq %u\n", tc->rtt_seq);
   s = format (s, " tsval_recent %u tsval_recent_age %u\n", tc->tsval_recent,
 	      tcp_time_now () - tc->tsval_recent_age);
-  s = format (s, " scoreboard: %U\n", format_tcp_scoreboard, &tc->sack_sb,
-	      tc);
+  s = format (s, " rto %u rto_boff %u srtt %u rttvar %u rtt_ts %2.5f ",
+	      tc->rto, tc->rto_boff, tc->srtt, tc->rttvar, tc->rtt_ts);
+  s = format (s, "rtt_seq %u\n", tc->rtt_seq - tc->iss);
+  s = format (s, " cong:   %U", format_tcp_congestion, tc);
+
+  if (tc->state >= TCP_STATE_ESTABLISHED)
+    {
+      s = format (s, " sboard: %U\n", format_tcp_scoreboard, &tc->sack_sb,
+		  tc);
+    }
   if (vec_len (tc->snd_sacks))
     s = format (s, " sacks tx: %U\n", format_tcp_sacks, tc);
 
   return s;
 }
 
-u8 *
+static u8 *
 format_tcp_connection_id (u8 * s, va_list * args)
 {
   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
@@ -837,15 +826,15 @@ format_tcp_connection_id (u8 * s, va_list * args)
     return s;
   if (tc->c_is_ip4)
     {
-      s = format (s, "[#%d][%s] %U:%d->%U:%d", tc->c_thread_index, "T",
-		  format_ip4_address, &tc->c_lcl_ip4,
+      s = format (s, "[%d:%d][%s] %U:%d->%U:%d", tc->c_thread_index,
+		  tc->c_s_index, "T", format_ip4_address, &tc->c_lcl_ip4,
 		  clib_net_to_host_u16 (tc->c_lcl_port), format_ip4_address,
 		  &tc->c_rmt_ip4, clib_net_to_host_u16 (tc->c_rmt_port));
     }
   else
     {
-      s = format (s, "[#%d][%s] %U:%d->%U:%d", tc->c_thread_index, "T",
-		  format_ip6_address, &tc->c_lcl_ip6,
+      s = format (s, "[%d:%d][%s] %U:%d->%U:%d", tc->c_thread_index,
+		  tc->c_s_index, "T", format_ip6_address, &tc->c_lcl_ip6,
 		  clib_net_to_host_u16 (tc->c_lcl_port), format_ip6_address,
 		  &tc->c_rmt_ip6, clib_net_to_host_u16 (tc->c_rmt_port));
     }
@@ -866,13 +855,13 @@ format_tcp_connection (u8 * s, va_list * args)
     {
       s = format (s, "%-15U", format_tcp_state, tc->state);
       if (verbose > 1)
-	s = format (s, " %U\n%U", format_tcp_timers, tc, format_tcp_vars, tc);
+	s = format (s, "\n%U", format_tcp_vars, tc);
     }
 
   return s;
 }
 
-u8 *
+static u8 *
 format_tcp_session (u8 * s, va_list * args)
 {
   u32 tci = va_arg (*args, u32);
@@ -888,7 +877,7 @@ format_tcp_session (u8 * s, va_list * args)
   return s;
 }
 
-u8 *
+static u8 *
 format_tcp_listener_session (u8 * s, va_list * args)
 {
   u32 tci = va_arg (*args, u32);
@@ -896,7 +885,7 @@ format_tcp_listener_session (u8 * s, va_list * args)
   return format (s, "%U", format_tcp_connection_id, tc);
 }
 
-u8 *
+static u8 *
 format_tcp_half_open_session (u8 * s, va_list * args)
 {
   u32 tci = va_arg (*args, u32);
@@ -952,7 +941,7 @@ format_tcp_rcv_sacks (u8 * s, va_list * args)
   return s;
 }
 
-u8 *
+static u8 *
 format_tcp_sack_hole (u8 * s, va_list * args)
 {
   sack_scoreboard_hole_t *hole = va_arg (*args, sack_scoreboard_hole_t *);
@@ -970,16 +959,22 @@ format_tcp_scoreboard (u8 * s, va_list * args)
   sack_scoreboard_t *sb = va_arg (*args, sack_scoreboard_t *);
   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
   sack_scoreboard_hole_t *hole;
+  u32 indent = format_get_indent (s);
+
   s = format (s, "sacked_bytes %u last_sacked_bytes %u lost_bytes %u\n",
 	      sb->sacked_bytes, sb->last_sacked_bytes, sb->lost_bytes);
-  s = format (s, " last_bytes_delivered %u high_sacked %u snd_una_adv %u\n",
-	      sb->last_bytes_delivered, sb->high_sacked, sb->snd_una_adv);
-  s = format (s, " cur_rxt_hole %u high_rxt %u rescue_rxt %u",
-	      sb->cur_rxt_hole, sb->high_rxt, sb->rescue_rxt);
+  s = format (s, "%Ulast_bytes_delivered %u high_sacked %u snd_una_adv %u\n",
+	      format_white_space, indent, sb->last_bytes_delivered,
+	      sb->high_sacked - tc->iss, sb->snd_una_adv);
+  s = format (s, "%Ucur_rxt_hole %u high_rxt %u rescue_rxt %u",
+	      format_white_space, indent, sb->cur_rxt_hole,
+	      sb->high_rxt - tc->iss, sb->rescue_rxt - tc->iss);
 
   hole = scoreboard_first_hole (sb);
   if (hole)
-    s = format (s, "\n head %u tail %u holes:\n", sb->head, sb->tail);
+    s = format (s, "\n%Uhead %u tail %u %u holes:\n%U", format_white_space,
+		indent, sb->head, sb->tail, pool_elts (sb->holes),
+		format_white_space, indent);
 
   while (hole)
     {
@@ -990,14 +985,14 @@ format_tcp_scoreboard (u8 * s, va_list * args)
   return s;
 }
 
-transport_connection_t *
+static transport_connection_t *
 tcp_session_get_transport (u32 conn_index, u32 thread_index)
 {
   tcp_connection_t *tc = tcp_connection_get (conn_index, thread_index);
   return &tc->connection;
 }
 
-transport_connection_t *
+static transport_connection_t *
 tcp_half_open_session_get_transport (u32 conn_index)
 {
   tcp_connection_t *tc = tcp_half_open_connection_get (conn_index);
@@ -1011,7 +1006,7 @@ tcp_half_open_session_get_transport (u32 conn_index)
  * the tcp options to be used in the next burst and subtracts their
  * length from the connection's snd_mss.
  */
-u16
+static u16
 tcp_session_send_mss (transport_connection_t * trans_conn)
 {
   tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
@@ -1019,7 +1014,7 @@ tcp_session_send_mss (transport_connection_t * trans_conn)
   /* Ensure snd_mss does accurately reflect the amount of data we can push
    * in a segment. This also makes sure that options are updated according to
    * the current state of the connection. */
-  tcp_update_snd_mss (tc);
+  tcp_update_burst_snd_vars (tc);
 
   return tc->snd_mss;
 }
@@ -1051,70 +1046,47 @@ tcp_round_snd_space (tcp_connection_t * tc, u32 snd_space)
  * @param tc tcp connection
  * @return number of bytes session is allowed to write
  */
-u32
-tcp_snd_space (tcp_connection_t * tc)
+static inline u32
+tcp_snd_space_inline (tcp_connection_t * tc)
 {
   int snd_space, snt_limited;
 
-  if (PREDICT_TRUE (tcp_in_cong_recovery (tc) == 0))
-    {
-      snd_space = tcp_available_output_snd_space (tc);
-
-      /* If we haven't gotten dupacks or if we did and have gotten sacked
-       * bytes then we can still send as per Limited Transmit (RFC3042) */
-      if (PREDICT_FALSE (tc->rcv_dupacks != 0
-			 && (tcp_opts_sack_permitted (tc)
-			     && tc->sack_sb.last_sacked_bytes == 0)))
-	{
-	  if (tc->rcv_dupacks == 1 && tc->limited_transmit != tc->snd_nxt)
-	    tc->limited_transmit = tc->snd_nxt;
-	  ASSERT (seq_leq (tc->limited_transmit, tc->snd_nxt));
+  if (PREDICT_FALSE (tcp_in_fastrecovery (tc)))
+    return 0;
 
-	  snt_limited = tc->snd_nxt - tc->limited_transmit;
-	  snd_space = clib_max (2 * tc->snd_mss - snt_limited, 0);
-	}
-      return tcp_round_snd_space (tc, snd_space);
-    }
+  snd_space = tcp_available_output_snd_space (tc);
 
-  if (tcp_in_recovery (tc))
+  /* If we haven't gotten dupacks or if we did and have gotten sacked
+   * bytes then we can still send as per Limited Transmit (RFC3042) */
+  if (PREDICT_FALSE (tc->rcv_dupacks != 0
+		     && (tcp_opts_sack_permitted (tc)
+			 && tc->sack_sb.last_sacked_bytes == 0)))
     {
-      tc->snd_nxt = tc->snd_una_max;
-      snd_space = tcp_available_snd_wnd (tc) - tc->snd_rxt_bytes
-	- (tc->snd_una_max - tc->snd_congestion);
-      if (snd_space <= 0 || (tc->snd_una_max - tc->snd_una) >= tc->snd_wnd)
-	return 0;
-      return tcp_round_snd_space (tc, snd_space);
-    }
+      if (tc->rcv_dupacks == 1 && tc->limited_transmit != tc->snd_nxt)
+	tc->limited_transmit = tc->snd_nxt;
+      ASSERT (seq_leq (tc->limited_transmit, tc->snd_nxt));
 
-  /* RFC 5681: When previously unsent data is available and the new value of
-   * cwnd and the receiver's advertised window allow, a TCP SHOULD send 1*SMSS
-   * bytes of previously unsent data. */
-  if (tcp_in_fastrecovery (tc) && !tcp_fastrecovery_sent_1_smss (tc))
-    {
-      if (tcp_available_output_snd_space (tc) < tc->snd_mss)
-	return 0;
-      tcp_fastrecovery_1_smss_on (tc);
-      return tc->snd_mss;
+      snt_limited = tc->snd_nxt - tc->limited_transmit;
+      snd_space = clib_max (2 * tc->snd_mss - snt_limited, 0);
     }
-
-  return 0;
+  return tcp_round_snd_space (tc, snd_space);
 }
 
 u32
-tcp_session_send_space (transport_connection_t * trans_conn)
+tcp_snd_space (tcp_connection_t * tc)
 {
-  tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
-  return clib_min (tcp_snd_space (tc),
-		   tc->snd_wnd - (tc->snd_nxt - tc->snd_una));
+  return tcp_snd_space_inline (tc);
 }
 
-i32
-tcp_rcv_wnd_available (tcp_connection_t * tc)
+static u32
+tcp_session_send_space (transport_connection_t * trans_conn)
 {
-  return (i32) tc->rcv_wnd - (tc->rcv_nxt - tc->rcv_las);
+  tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
+  return clib_min (tcp_snd_space_inline (tc),
+		   tc->snd_wnd - (tc->snd_nxt - tc->snd_una));
 }
 
-u32
+static u32
 tcp_session_tx_fifo_offset (transport_connection_t * trans_conn)
 {
   tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
@@ -1125,11 +1097,31 @@ tcp_session_tx_fifo_offset (transport_connection_t * trans_conn)
   return (tc->snd_nxt - tc->snd_una);
 }
 
+static void
+tcp_update_time (f64 now, u8 thread_index)
+{
+  tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
+
+  tcp_set_time_now (wrk);
+  tw_timer_expire_timers_16t_2w_512sl (&wrk->timer_wheel, now);
+  tcp_do_fastretransmits (wrk);
+  tcp_send_acks (wrk);
+  tcp_flush_frames_to_output (wrk);
+}
+
+static u32
+tcp_session_push_header (transport_connection_t * tconn, vlib_buffer_t * b)
+{
+  tcp_connection_t *tc = (tcp_connection_t *) tconn;
+  return tcp_push_header (tc, b);
+}
+
 /* *INDENT-OFF* */
 const static transport_proto_vft_t tcp_proto = {
+  .enable = vnet_tcp_enable_disable,
   .bind = tcp_session_bind,
   .unbind = tcp_session_unbind,
-  .push_header = tcp_push_header,
+  .push_header = tcp_session_push_header,
   .get_connection = tcp_session_get_transport,
   .get_listener = tcp_session_get_listener,
   .get_half_open = tcp_half_open_session_get_transport,
@@ -1138,14 +1130,44 @@ const static transport_proto_vft_t tcp_proto = {
   .cleanup = tcp_session_cleanup,
   .send_mss = tcp_session_send_mss,
   .send_space = tcp_session_send_space,
+  .update_time = tcp_update_time,
   .tx_fifo_offset = tcp_session_tx_fifo_offset,
   .format_connection = format_tcp_session,
   .format_listener = format_tcp_listener_session,
   .format_half_open = format_tcp_half_open_session,
+  .tx_type = TRANSPORT_TX_PEEK,
+  .service_type = TRANSPORT_SERVICE_VC,
 };
 /* *INDENT-ON* */
 
 void
+tcp_connection_tx_pacer_update (tcp_connection_t * tc)
+{
+  f64 srtt;
+  u64 rate;
+
+  if (!transport_connection_is_tx_paced (&tc->connection))
+    return;
+
+  srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us);
+  /* TODO should constrain to interface's max throughput but
+   * we don't have link speeds for sw ifs ..*/
+  rate = tc->cwnd / srtt;
+  transport_connection_tx_pacer_update (&tc->connection, rate);
+}
+
+void
+tcp_connection_tx_pacer_reset (tcp_connection_t * tc, u32 window,
+			       u32 start_bucket)
+{
+  tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+  u32 byte_rate = window / ((f64) TCP_TICK * tc->srtt);
+  u64 last_time = wrk->vm->clib_time.last_cpu_time;
+  transport_connection_tx_pacer_reset (&tc->connection, byte_rate,
+				       start_bucket, last_time);
+}
+
+static void
 tcp_timer_keep_handler (u32 conn_index)
 {
   u32 thread_index = vlib_get_thread_index ();
@@ -1157,7 +1179,7 @@ tcp_timer_keep_handler (u32 conn_index)
   tcp_connection_close (tc);
 }
 
-void
+static void
 tcp_timer_establish_handler (u32 conn_index)
 {
   tcp_connection_t *tc;
@@ -1166,7 +1188,7 @@ tcp_timer_establish_handler (u32 conn_index)
   if (tc)
     {
       ASSERT (tc->state == TCP_STATE_SYN_SENT);
-      stream_session_connect_notify (&tc->connection, 1 /* fail */ );
+      session_stream_connect_notify (&tc->connection, 1 /* fail */ );
       TCP_DBG ("establish pop: %U", format_tcp_connection, tc, 2);
     }
   else
@@ -1185,7 +1207,7 @@ tcp_timer_establish_handler (u32 conn_index)
   tcp_connection_cleanup (tc);
 }
 
-void
+static void
 tcp_timer_waitclose_handler (u32 conn_index)
 {
   u32 thread_index = vlib_get_thread_index ();
@@ -1205,6 +1227,10 @@ tcp_timer_waitclose_handler (u32 conn_index)
 	  clib_warning ("FIN was sent and still in CLOSE WAIT. Weird!");
 	}
 
+      /* Make sure we don't try to send unsent data */
+      tcp_connection_timers_reset (tc);
+      tcp_cong_recovery_off (tc);
+      tc->snd_una_max = tc->snd_nxt = tc->snd_una;
       tcp_send_fin (tc);
       tc->state = TCP_STATE_LAST_ACK;
 
@@ -1250,13 +1276,13 @@ tcp_expired_timers_dispatch (u32 * expired_timers)
     }
 }
 
-void
+static void
 tcp_initialize_timer_wheels (tcp_main_t * tm)
 {
   tw_timer_wheel_16t_2w_512sl_t *tw;
   /* *INDENT-OFF* */
   foreach_vlib_main (({
-    tw = &tm->timer_wheels[ii];
+    tw = &tm->wrk_ctx[ii].timer_wheel;
     tw_timer_wheel_init_16t_2w_512sl (tw, tcp_expired_timers_dispatch,
 				      100e-3 /* timer period 100ms */ , ~0);
     tw->last_run_time = vlib_time_now (this_vlib_main);
@@ -1264,18 +1290,15 @@ tcp_initialize_timer_wheels (tcp_main_t * tm)
   /* *INDENT-ON* */
 }
 
-clib_error_t *
+static clib_error_t *
 tcp_main_enable (vlib_main_t * vm)
 {
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  ip_protocol_info_t *pi;
-  ip_main_t *im = &ip_main;
   vlib_thread_main_t *vtm = vlib_get_thread_main ();
+  u32 num_threads, n_workers, prealloc_conn_per_wrk;
+  tcp_connection_t *tc __attribute__ ((unused));
+  tcp_main_t *tm = vnet_get_tcp_main ();
   clib_error_t *error = 0;
-  u32 num_threads;
   int thread;
-  tcp_connection_t *tc __attribute__ ((unused));
-  u32 preallocated_connections_per_thread;
 
   if ((error = vlib_call_init_function (vm, ip_main_init)))
     return error;
@@ -1288,47 +1311,39 @@ tcp_main_enable (vlib_main_t * vm)
    * Registrations
    */
 
-  /* Register with IP */
-  pi = ip_get_protocol_info (im, IP_PROTOCOL_TCP);
-  if (pi == 0)
-    return clib_error_return (0, "TCP protocol info AWOL");
-  pi->format_header = format_tcp_header;
-  pi->unformat_pg_edit = unformat_pg_tcp_header;
-
   ip4_register_protocol (IP_PROTOCOL_TCP, tcp4_input_node.index);
   ip6_register_protocol (IP_PROTOCOL_TCP, tcp6_input_node.index);
 
-  /* Register as transport with session layer */
-  session_register_transport (TRANSPORT_PROTO_TCP, 1, &tcp_proto);
-  session_register_transport (TRANSPORT_PROTO_TCP, 0, &tcp_proto);
-
   /*
    * Initialize data structures
    */
 
   num_threads = 1 /* main thread */  + vtm->n_threads;
   vec_validate (tm->connections, num_threads - 1);
+  vec_validate (tm->wrk_ctx, num_threads - 1);
+  n_workers = num_threads == 1 ? 1 : vtm->n_threads;
+  prealloc_conn_per_wrk = tm->preallocated_connections / n_workers;
 
-  /*
-   * Preallocate connections. Assume that thread 0 won't
-   * use preallocated threads when running multi-core
-   */
-  if (num_threads == 1)
-    {
-      thread = 0;
-      preallocated_connections_per_thread = tm->preallocated_connections;
-    }
-  else
-    {
-      thread = 1;
-      preallocated_connections_per_thread =
-	tm->preallocated_connections / (num_threads - 1);
-    }
-  for (; thread < num_threads; thread++)
+  for (thread = 0; thread < num_threads; thread++)
     {
-      if (preallocated_connections_per_thread)
-	pool_init_fixed (tm->connections[thread],
-			 preallocated_connections_per_thread);
+      vec_validate (tm->wrk_ctx[thread].pending_fast_rxt, 255);
+      vec_validate (tm->wrk_ctx[thread].ongoing_fast_rxt, 255);
+      vec_validate (tm->wrk_ctx[thread].postponed_fast_rxt, 255);
+      vec_validate (tm->wrk_ctx[thread].pending_deq_acked, 255);
+      vec_validate (tm->wrk_ctx[thread].pending_acks, 255);
+      vec_reset_length (tm->wrk_ctx[thread].pending_fast_rxt);
+      vec_reset_length (tm->wrk_ctx[thread].ongoing_fast_rxt);
+      vec_reset_length (tm->wrk_ctx[thread].postponed_fast_rxt);
+      vec_reset_length (tm->wrk_ctx[thread].pending_deq_acked);
+      vec_reset_length (tm->wrk_ctx[thread].pending_acks);
+      tm->wrk_ctx[thread].vm = vlib_mains[thread];
+
+      /*
+       * Preallocate connections. Assume that thread 0 won't
+       * use preallocated threads when running multi-core
+       */
+      if ((thread > 0 || num_threads == 1) && prealloc_conn_per_wrk)
+	pool_init_fixed (tm->connections[thread], prealloc_conn_per_wrk);
     }
 
   /*
@@ -1338,45 +1353,21 @@ tcp_main_enable (vlib_main_t * vm)
     pool_init_fixed (tm->half_open_connections,
 		     tm->preallocated_half_open_connections);
 
-  /* Initialize per worker thread tx buffers (used for control messages) */
-  vec_validate (tm->tx_buffers, num_threads - 1);
-
-  /* Initialize timer wheels */
-  vec_validate (tm->timer_wheels, num_threads - 1);
-  tcp_initialize_timer_wheels (tm);
-
   /* Initialize clocks per tick for TCP timestamp. Used to compute
    * monotonically increasing timestamps. */
   tm->tstamp_ticks_per_clock = vm->clib_time.seconds_per_clock
     / TCP_TSTAMP_RESOLUTION;
 
-  if (tm->local_endpoints_table_buckets == 0)
-    tm->local_endpoints_table_buckets = 250000;
-  if (tm->local_endpoints_table_memory == 0)
-    tm->local_endpoints_table_memory = 512 << 20;
-
-  clib_bihash_init_24_8 (&tm->local_endpoints_table, "local endpoint table",
-			 tm->local_endpoints_table_buckets,
-			 tm->local_endpoints_table_memory);
-
-  /* Initialize [port-allocator] random number seed */
-  tm->port_allocator_seed = (u32) clib_cpu_time_now ();
-
   if (num_threads > 1)
     {
       clib_spinlock_init (&tm->half_open_lock);
-      clib_spinlock_init (&tm->local_endpoints_lock);
     }
 
-  vec_validate (tm->tx_frames[0], num_threads - 1);
-  vec_validate (tm->tx_frames[1], num_threads - 1);
-  vec_validate (tm->ip_lookup_tx_frames[0], num_threads - 1);
-  vec_validate (tm->ip_lookup_tx_frames[1], num_threads - 1);
+  tcp_initialize_timer_wheels (tm);
 
   tm->bytes_per_buffer = vlib_buffer_free_list_buffer_size
     (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 
-  vec_validate (tm->time_now, num_threads - 1);
   return error;
 }
 
@@ -1408,12 +1399,31 @@ tcp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add)
     tm->punt_unknown6 = is_add;
 }
 
-clib_error_t *
+static clib_error_t *
 tcp_init (vlib_main_t * vm)
 {
   tcp_main_t *tm = vnet_get_tcp_main ();
+  ip_main_t *im = &ip_main;
+  ip_protocol_info_t *pi;
+
+  /* Session layer, and by implication tcp, are disabled by default */
   tm->is_enabled = 0;
+
+  /* Register with IP for header parsing */
+  pi = ip_get_protocol_info (im, IP_PROTOCOL_TCP);
+  if (pi == 0)
+    return clib_error_return (0, "TCP protocol info AWOL");
+  pi->format_header = format_tcp_header;
+  pi->unformat_pg_edit = unformat_pg_tcp_header;
+
+  /* Register as transport with session layer */
+  transport_register_protocol (TRANSPORT_PROTO_TCP, &tcp_proto,
+			       FIB_PROTOCOL_IP4, tcp4_output_node.index);
+  transport_register_protocol (TRANSPORT_PROTO_TCP, &tcp_proto,
+			       FIB_PROTOCOL_IP6, tcp6_output_node.index);
+
   tcp_api_reference ();
+  tm->tx_pacing = 1;
   return 0;
 }
 
@@ -1423,30 +1433,23 @@ static clib_error_t *
 tcp_config_fn (vlib_main_t * vm, unformat_input_t * input)
 {
   tcp_main_t *tm = vnet_get_tcp_main ();
-  u64 tmp;
 
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
-      if (unformat
-	  (input, "preallocated-connections %d",
-	   &tm->preallocated_connections))
+      if (unformat (input, "preallocated-connections %d",
+		    &tm->preallocated_connections))
 	;
       else if (unformat (input, "preallocated-half-open-connections %d",
 			 &tm->preallocated_half_open_connections))
 	;
-      else if (unformat (input, "local-endpoints-table-memory %U",
-			 unformat_memory_size, &tmp))
-	{
-	  if (tmp >= 0x100000000)
-	    return clib_error_return (0, "memory size %llx (%lld) too large",
-				      tmp, tmp);
-	  tm->local_endpoints_table_memory = tmp;
-	}
-      else if (unformat (input, "local-endpoints-table-buckets %d",
-			 &tm->local_endpoints_table_buckets))
+      else if (unformat (input, "buffer-fail-fraction %f",
+			 &tm->buffer_fail_fraction))
 	;
-
-
+      else if (unformat (input, "max-rx-fifo %U", unformat_memory_size,
+			 &tm->max_rx_fifo))
+	;
+      else if (unformat (input, "no-tx-pacing"))
+	tm->tx_pacing = 0;
       else
 	return clib_error_return (0, "unknown input `%U'",
 				  format_unformat_error, input);
@@ -1484,7 +1487,7 @@ tcp_configure_v4_source_address_range (vlib_main_t * vm,
 			      ip4_address_t * hi_addr, u32 fib_index,
 			      int is_del);
 
-  memset (&prefix, 0, sizeof (prefix));
+  clib_memset (&prefix, 0, sizeof (prefix));
 
   fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id);
 
@@ -1569,7 +1572,7 @@ tcp_configure_v6_source_address_range (vlib_main_t * vm,
   fib_node_index_t fei;
   u32 sw_if_index;
 
-  memset (&prefix, 0, sizeof (prefix));
+  clib_memset (&prefix, 0, sizeof (prefix));
 
   fib_index = fib_table_find (FIB_PROTOCOL_IP6, table_id);
 
@@ -1657,7 +1660,7 @@ tcp_src_address (vlib_main_t * vm,
 	v6set = 1;
       else if (unformat (input, "%U", unformat_ip6_address, &v6start))
 	{
-	  memcpy (&v6end, &v6start, sizeof (v4start));
+	  memcpy (&v6end, &v6start, sizeof (v6start));
 	  v6set = 1;
 	}
       else if (unformat (input, "fib-table %d", &table_id))
@@ -1791,10 +1794,16 @@ tcp_scoreboard_replay (u8 * s, tcp_connection_t * tc, u8 verbose)
   tcp_connection_t _dummy_tc, *dummy_tc = &_dummy_tc;
   sack_block_t *block;
 
+  if (!TCP_SCOREBOARD_TRACE)
+    {
+      s = format (s, "scoreboard tracing not enabled");
+      return s;
+    }
+
   if (!tc)
     return s;
 
-  memset (dummy_tc, 0, sizeof (*dummy_tc));
+  clib_memset (dummy_tc, 0, sizeof (*dummy_tc));
   tcp_connection_timers_init (dummy_tc);
   scoreboard_init (&dummy_tc->sack_sb);
   dummy_tc->rcv_opts.flags |= TCP_OPTS_FLAG_SACK;
@@ -1802,9 +1811,6 @@ tcp_scoreboard_replay (u8 * s, tcp_connection_t * tc, u8 verbose)
 #if TCP_SCOREBOARD_TRACE
   trace = tc->sack_sb.trace;
   trace_len = vec_len (tc->sack_sb.trace);
-#else
-  trace = 0;
-  trace_len = 0;
 #endif
 
   for (i = 0; i < trace_len; i++)