X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsctp%2Fsctp.c;h=41548bc0d7ab1fdb0f76b53f28a4b781cc82e4e5;hb=5665cedf57165c05d00f28de06b627047902ffce;hp=d0f37f4346e13545be9c42ec031d0a38737db03f;hpb=8ad6a2dfed0a7248be9d005dd04c76da142f2238;p=vpp.git

diff --git a/src/vnet/sctp/sctp.c b/src/vnet/sctp/sctp.c
index d0f37f4346e..41548bc0d7a 100644
--- a/src/vnet/sctp/sctp.c
+++ b/src/vnet/sctp/sctp.c
@@ -25,12 +25,13 @@ sctp_connection_bind (u32 session_index, transport_endpoint_t * tep)
   void *iface_ip;
 
   pool_get (tm->listener_pool, listener);
-  memset (listener, 0, sizeof (*listener));
+  clib_memset (listener, 0, sizeof (*listener));
 
-  listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = listener;
-  listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index =
+  listener->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
+    SCTP_PRIMARY_PATH_IDX;
+  listener->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
     listener - tm->listener_pool;
-  listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.lcl_port = tep->port;
+  listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.lcl_port = tep->port;
 
   /* If we are provided a sw_if_index, bind using one of its IPs */
   if (ip_is_zero (&tep->ip, 1) && tep->sw_if_index != ENDPOINT_INVALID_INDEX)
@@ -39,20 +40,26 @@ sctp_connection_bind (u32 session_index, transport_endpoint_t * tep)
 						 tep->is_ip4)))
 	ip_set (&tep->ip, iface_ip, tep->is_ip4);
     }
-  ip_copy (&listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.lcl_ip,
+  ip_copy (&listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.lcl_ip,
 	   &tep->ip, tep->is_ip4);
 
-  listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.is_ip4 = tep->is_ip4;
-  listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.proto =
+  u32 mtu = tep->is_ip4 ? vnet_sw_interface_get_mtu (vnet_get_main (),
+						     tep->sw_if_index,
+						     VNET_MTU_IP4) :
+    vnet_sw_interface_get_mtu (vnet_get_main (), tep->sw_if_index,
+			       VNET_MTU_IP6);
+  listener->sub_conn[SCTP_PRIMARY_PATH_IDX].PMTU = mtu;
+  listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.is_ip4 = tep->is_ip4;
+  listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.proto =
     TRANSPORT_PROTO_SCTP;
-  listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_s_index = session_index;
-  listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.fib_index =
+  listener->sub_conn[SCTP_PRIMARY_PATH_IDX].c_s_index = session_index;
+  listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.fib_index =
     tep->fib_index;
   listener->state = SCTP_STATE_CLOSED;
 
   sctp_connection_timers_init (listener);
 
-  return listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index;
+  return listener->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index;
 }
 
 u32
@@ -71,7 +78,7 @@ sctp_connection_unbind (u32 listener_index)
 
   /* Poison the entry */
   if (CLIB_DEBUG > 0)
-    memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
+    clib_memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
 
   pool_put_index (tm->listener_pool, listener_index);
 }
@@ -135,6 +142,7 @@ sctp_connection_timers_init (sctp_connection_t * sctp_conn)
   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
     {
       sctp_conn->sub_conn[i].RTO = SCTP_RTO_INIT;
+
       for (j = 0; j < SCTP_N_TIMERS; j++)
 	{
 	  sctp_conn->sub_conn[i].timers[j] = SCTP_TIMER_HANDLE_INVALID;
@@ -177,25 +185,44 @@ format_sctp_state (u8 * s, va_list * args)
 u8 *
 format_sctp_connection_id (u8 * s, va_list * args)
 {
-  /*
-     sctp_connection_t *sctp_conn = va_arg (*args, sctp_connection_t *);
-     if (!sctp_conn)
-     return s;
-     if (sctp_conn->c_is_ip4)
-     {
-     s = format (s, "[#%d][%s] %U:%d->%U:%d", sctp_conn->c_thread_index, "T",
-     format_ip4_address, &sctp_conn->c_lcl_ip4,
-     clib_net_to_host_u16 (sctp_conn->c_lcl_port), format_ip4_address,
-     &sctp_conn->c_rmt_ip4, clib_net_to_host_u16 (sctp_conn->c_rmt_port));
-     }
-     else
-     {
-     s = format (s, "[#%d][%s] %U:%d->%U:%d", sctp_conn->c_thread_index, "T",
-     format_ip6_address, &sctp_conn->c_lcl_ip6,
-     clib_net_to_host_u16 (sctp_conn->c_lcl_port), format_ip6_address,
-     &sctp_conn->c_rmt_ip6, clib_net_to_host_u16 (sctp_conn->c_rmt_port));
-     }
-   */
+  sctp_connection_t *sctp_conn = va_arg (*args, sctp_connection_t *);
+  if (!sctp_conn)
+    return s;
+
+  u8 i;
+  for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
+    {
+      if (sctp_conn->sub_conn[i].connection.is_ip4)
+	{
+	  s = format (s, "%U[#%d][%s] %U:%d->%U:%d",
+		      s,
+		      sctp_conn->sub_conn[i].connection.thread_index,
+		      "T",
+		      format_ip4_address,
+		      &sctp_conn->sub_conn[i].connection.lcl_ip.ip4,
+		      clib_net_to_host_u16 (sctp_conn->sub_conn[i].
+					    connection.lcl_port),
+		      format_ip4_address,
+		      &sctp_conn->sub_conn[i].connection.rmt_ip.ip4,
+		      clib_net_to_host_u16 (sctp_conn->sub_conn[i].
+					    connection.rmt_port));
+	}
+      else
+	{
+	  s = format (s, "%U[#%d][%s] %U:%d->%U:%d",
+		      s,
+		      sctp_conn->sub_conn[i].connection.thread_index,
+		      "T",
+		      format_ip6_address,
+		      &sctp_conn->sub_conn[i].connection.lcl_ip.ip6,
+		      clib_net_to_host_u16 (sctp_conn->sub_conn[i].
+					    connection.lcl_port),
+		      format_ip6_address,
+		      &sctp_conn->sub_conn[i].connection.rmt_ip.ip6,
+		      clib_net_to_host_u16 (sctp_conn->sub_conn[i].
+					    connection.rmt_port));
+	}
+    }
   return s;
 }
 
@@ -234,103 +261,176 @@ sctp_init_snd_vars (sctp_connection_t * sctp_conn)
   time_now = sctp_time_now ();
 
   sctp_conn->local_initial_tsn = random_u32 (&time_now);
+  sctp_conn->last_unacked_tsn = sctp_conn->local_initial_tsn;
+  sctp_conn->next_tsn = sctp_conn->local_initial_tsn + 1;
+
   sctp_conn->remote_initial_tsn = 0x0;
   sctp_conn->last_rcvd_tsn = sctp_conn->remote_initial_tsn;
-  sctp_conn->next_tsn = sctp_conn->local_initial_tsn + 1;
 }
 
-/**
- * Update max segment size we're able to process.
- *
- * The value is constrained by our interface's MTU and IP options. It is
- * also what we advertise to our peer.
- */
-void
-sctp_update_rcv_mss (sctp_connection_t * sctp_conn)
+always_inline sctp_connection_t *
+sctp_sub_connection_add (u8 thread_index)
 {
-  sctp_conn->smallest_PMTU = DEFAULT_A_RWND;	/* TODO find our iface MTU */
-  sctp_conn->a_rwnd = DEFAULT_A_RWND - sizeof (sctp_full_hdr_t);
-  sctp_conn->rcv_opts.a_rwnd = sctp_conn->a_rwnd;
-  sctp_conn->rcv_a_rwnd = sctp_conn->a_rwnd;	/* This will be updated by our congestion algos */
+  sctp_main_t *tm = vnet_get_sctp_main ();
+  sctp_connection_t *sctp_conn = tm->connections[thread_index];
+
+  u8 subconn_idx = sctp_next_avail_subconn (sctp_conn);
+
+  ASSERT (subconn_idx < MAX_SCTP_CONNECTIONS);
+
+  sctp_conn->sub_conn[subconn_idx].connection.c_index =
+    sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.c_index;
+  sctp_conn->sub_conn[subconn_idx].connection.thread_index = thread_index;
+  sctp_conn->sub_conn[subconn_idx].subconn_idx = subconn_idx;
+
+  return sctp_conn;
 }
 
-void
-sctp_init_mss (sctp_connection_t * sctp_conn)
+u8
+sctp_sub_connection_add_ip4 (vlib_main_t * vm,
+			     ip4_address_t * lcl_addr,
+			     ip4_address_t * rmt_addr)
+{
+  sctp_connection_t *sctp_conn = sctp_sub_connection_add (vm->thread_index);
+
+  u8 subconn_idx = sctp_next_avail_subconn (sctp_conn);
+
+  if (subconn_idx == MAX_SCTP_CONNECTIONS)
+    return SCTP_ERROR_MAX_CONNECTIONS;
+
+  clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.lcl_ip,
+	       &lcl_addr, sizeof (lcl_addr));
+
+  clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.rmt_ip,
+	       &rmt_addr, sizeof (rmt_addr));
+
+  sctp_conn->forming_association_changed = 1;
+
+  return SCTP_ERROR_NONE;
+}
+
+u8
+sctp_sub_connection_del_ip4 (ip4_address_t * lcl_addr,
+			     ip4_address_t * rmt_addr)
 {
-  SCTP_DBG ("CONN_INDEX = %u",
-	    sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index);
+  sctp_main_t *sctp_main = vnet_get_sctp_main ();
 
-  u16 default_a_rwnd = 536;
-  sctp_update_rcv_mss (sctp_conn);
+  u32 thread_idx = vlib_get_thread_index ();
+  u8 i;
 
-  /* TODO cache mss and consider PMTU discovery */
-  sctp_conn->snd_a_rwnd =
-    clib_min (sctp_conn->rcv_opts.a_rwnd, sctp_conn->a_rwnd);
+  ASSERT (thread_idx == 0);
 
-  if (sctp_conn->snd_a_rwnd < sizeof (sctp_full_hdr_t))
+  for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
     {
-      SCTP_ADV_DBG ("sctp_conn->snd_a_rwnd < sizeof(sctp_full_hdr_t)");
-      /* Assume that at least the min default mss works */
-      sctp_conn->snd_a_rwnd = default_a_rwnd;
-      sctp_conn->rcv_opts.a_rwnd = default_a_rwnd;
+      sctp_connection_t *sctp_conn = sctp_main->connections[thread_idx];
+      sctp_sub_connection_t *sub_conn =
+	&sctp_main->connections[thread_idx]->sub_conn[i];
+      ip46_address_t *lcl_ip =
+	&sctp_main->connections[thread_idx]->sub_conn[i].connection.lcl_ip;
+      ip46_address_t *rmt_ip =
+	&sctp_main->connections[thread_idx]->sub_conn[i].connection.rmt_ip;
+
+      if (!sub_conn->connection.is_ip4)
+	continue;
+      if (lcl_ip->ip4.as_u32 == lcl_addr->as_u32 &&
+	  rmt_ip->ip4.as_u32 == rmt_addr->as_u32)
+	{
+	  sub_conn->state = SCTP_SUBCONN_STATE_DOWN;
+	  sctp_conn->forming_association_changed = 1;
+	  break;
+	}
     }
-
-  ASSERT (sctp_conn->snd_a_rwnd > sizeof (sctp_full_hdr_t));
+  return SCTP_ERROR_NONE;
 }
 
-always_inline sctp_connection_t *
-sctp_sub_connection_add (u8 thread_index)
+u8
+sctp_sub_connection_add_ip6 (vlib_main_t * vm,
+			     ip6_address_t * lcl_addr,
+			     ip6_address_t * rmt_addr)
 {
-  sctp_main_t *tm = vnet_get_sctp_main ();
-  sctp_connection_t *sctp_conn = tm->connections[thread_index];
+  sctp_connection_t *sctp_conn = sctp_sub_connection_add (vm->thread_index);
 
-  sctp_conn->sub_conn[sctp_conn->next_avail_sub_conn].connection.c_index =
-    sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index;
-  sctp_conn->sub_conn[sctp_conn->next_avail_sub_conn].
-    connection.thread_index = thread_index;
-  sctp_conn->sub_conn[sctp_conn->next_avail_sub_conn].parent = sctp_conn;
+  u8 subconn_idx = sctp_next_avail_subconn (sctp_conn);
 
-  sctp_conn->next_avail_sub_conn += 1;
+  if (subconn_idx == MAX_SCTP_CONNECTIONS)
+    return SCTP_ERROR_MAX_CONNECTIONS;
 
-  return sctp_conn;
+  clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.lcl_ip,
+	       &lcl_addr, sizeof (lcl_addr));
+
+  clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.rmt_ip,
+	       &rmt_addr, sizeof (rmt_addr));
+
+  sctp_conn->forming_association_changed = 1;
+
+  return SCTP_ERROR_NONE;
 }
 
-void
-sctp_sub_connection_add_ip4 (u8 thread_index,
-			     sctp_ipv4_addr_param_t * ipv4_addr)
+u8
+sctp_sub_connection_del_ip6 (ip6_address_t * lcl_addr,
+			     ip6_address_t * rmt_addr)
 {
-  sctp_connection_t *sctp_conn = sctp_sub_connection_add (thread_index);
+  sctp_main_t *sctp_main = vnet_get_sctp_main ();
 
-  clib_memcpy (&sctp_conn->
-	       sub_conn[sctp_conn->next_avail_sub_conn].connection.lcl_ip.ip4,
-	       &ipv4_addr->address, sizeof (ipv4_addr->address));
+  u32 thread_idx = vlib_get_thread_index ();
+  u8 i;
+
+  ASSERT (thread_idx == 0);
+
+  for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
+    {
+      sctp_connection_t *sctp_conn = sctp_main->connections[thread_idx];
+      sctp_sub_connection_t *sub_conn =
+	&sctp_main->connections[thread_idx]->sub_conn[i];
+      ip46_address_t *lcl_ip =
+	&sctp_main->connections[thread_idx]->sub_conn[i].connection.lcl_ip;
+      ip46_address_t *rmt_ip =
+	&sctp_main->connections[thread_idx]->sub_conn[i].connection.rmt_ip;
+
+      if (!sub_conn->connection.is_ip4)
+	continue;
+      if ((lcl_ip->ip6.as_u64[0] == lcl_addr->as_u64[0]
+	   && lcl_ip->ip6.as_u64[1] == lcl_addr->as_u64[1])
+	  && (rmt_ip->ip6.as_u64[0] == rmt_addr->as_u64[0]
+	      && rmt_ip->ip6.as_u64[1] == rmt_addr->as_u64[1]))
+	{
+	  sub_conn->state = SCTP_SUBCONN_STATE_DOWN;
+	  sctp_conn->forming_association_changed = 1;
+	  break;
+	}
+    }
+  return SCTP_ERROR_NONE;
 }
 
-void
-sctp_sub_connection_add_ip6 (u8 thread_index,
-			     sctp_ipv6_addr_param_t * ipv6_addr)
+u8
+sctp_configure (sctp_user_configuration_t config)
 {
-  sctp_connection_t *sctp_conn = sctp_sub_connection_add (thread_index);
+  sctp_main_t *sctp_main = vnet_get_sctp_main ();
+
+  u32 thread_idx = vlib_get_thread_index ();
 
-  clib_memcpy (&sctp_conn->
-	       sub_conn[sctp_conn->next_avail_sub_conn].connection.lcl_ip.ip6,
-	       &ipv6_addr->address, sizeof (ipv6_addr->address));
+  sctp_main->connections[thread_idx]->conn_config.never_delay_sack =
+    config.never_delay_sack;
+  sctp_main->connections[thread_idx]->conn_config.never_bundle =
+    config.never_bundle;
+
+  return 0;
 }
 
 sctp_connection_t *
 sctp_connection_new (u8 thread_index)
 {
-  sctp_main_t *tm = vnet_get_sctp_main ();
+  sctp_main_t *sctp_main = vnet_get_sctp_main ();
   sctp_connection_t *sctp_conn;
 
-  pool_get (tm->connections[thread_index], sctp_conn);
-  memset (sctp_conn, 0, sizeof (*sctp_conn));
-  sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = sctp_conn;
-  sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index =
-    sctp_conn - tm->connections[thread_index];
-  sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_thread_index = thread_index;
+  pool_get (sctp_main->connections[thread_index], sctp_conn);
+  clib_memset (sctp_conn, 0, sizeof (*sctp_conn));
+  sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
+    SCTP_PRIMARY_PATH_IDX;
+  sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
+    sctp_conn - sctp_main->connections[thread_index];
+  sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_thread_index = thread_index;
   sctp_conn->local_tag = 0;
-  sctp_conn->next_avail_sub_conn = 1;
 
   return sctp_conn;
 }
@@ -342,15 +442,16 @@ sctp_half_open_connection_new (u8 thread_index)
   sctp_connection_t *sctp_conn = 0;
   ASSERT (vlib_get_thread_index () == 0);
   pool_get (tm->half_open_connections, sctp_conn);
-  memset (sctp_conn, 0, sizeof (*sctp_conn));
-  sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index =
+  clib_memset (sctp_conn, 0, sizeof (*sctp_conn));
+  sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
     sctp_conn - tm->half_open_connections;
-  sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = sctp_conn;
+  sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
+    SCTP_PRIMARY_PATH_IDX;
   return sctp_conn;
 }
 
 static inline int
-sctp_connection_open (transport_endpoint_t * rmt)
+sctp_connection_open (transport_endpoint_cfg_t * rmt)
 {
   sctp_main_t *tm = vnet_get_sctp_main ();
   sctp_connection_t *sctp_conn;
@@ -359,7 +460,7 @@ sctp_connection_open (transport_endpoint_t * rmt)
   uword thread_id;
   int rv;
 
-  u8 idx = sctp_pick_conn_idx_on_state (SCTP_STATE_CLOSED);
+  u8 idx = SCTP_PRIMARY_PATH_IDX;
 
   /*
    * Allocate local endpoint
@@ -383,11 +484,17 @@ sctp_connection_open (transport_endpoint_t * rmt)
 
   clib_spinlock_lock_if_init (&tm->half_open_lock);
   sctp_conn = sctp_half_open_connection_new (thread_id);
+  u32 mtu = rmt->is_ip4 ? vnet_sw_interface_get_mtu (vnet_get_main (),
+						     rmt->peer.sw_if_index,
+						     VNET_MTU_IP4) :
+    vnet_sw_interface_get_mtu (vnet_get_main (), rmt->peer.sw_if_index,
+			       VNET_MTU_IP6);
+  sctp_conn->sub_conn[idx].PMTU = mtu;
 
   transport_connection_t *trans_conn = &sctp_conn->sub_conn[idx].connection;
   ip_copy (&trans_conn->rmt_ip, &rmt->ip, rmt->is_ip4);
   ip_copy (&trans_conn->lcl_ip, &lcl_addr, rmt->is_ip4);
-  sctp_conn->sub_conn[idx].parent = sctp_conn;
+  sctp_conn->sub_conn[idx].subconn_idx = idx;
   trans_conn->rmt_port = rmt->port;
   trans_conn->lcl_port = clib_host_to_net_u16 (lcl_port);
   trans_conn->is_ip4 = rmt->is_ip4;
@@ -422,28 +529,20 @@ sctp_connection_cleanup (sctp_connection_t * sctp_conn)
 				&sctp_conn->sub_conn[i].connection.lcl_ip,
 				sctp_conn->sub_conn[i].connection.lcl_port);
 
-  /* Check if connection is not yet fully established */
-  if (sctp_conn->state == SCTP_STATE_COOKIE_WAIT)
-    {
-
-    }
-  else
-    {
-      int thread_index =
-	sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.thread_index;
+  int thread_index =
+    sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.thread_index;
 
-      /* Make sure all timers are cleared */
-      sctp_connection_timers_reset (sctp_conn);
+  /* Make sure all timers are cleared */
+  sctp_connection_timers_reset (sctp_conn);
 
-      /* Poison the entry */
-      if (CLIB_DEBUG > 0)
-	memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
-      pool_put (tm->connections[thread_index], sctp_conn);
-    }
+  /* Poison the entry */
+  if (CLIB_DEBUG > 0)
+    clib_memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
+  pool_put (tm->connections[thread_index], sctp_conn);
 }
 
 int
-sctp_session_open (transport_endpoint_t * tep)
+sctp_session_open (transport_endpoint_cfg_t * tep)
 {
   return sctp_connection_open (tep);
 }
@@ -451,6 +550,22 @@ sctp_session_open (transport_endpoint_t * tep)
 u16
 sctp_check_outstanding_data_chunks (sctp_connection_t * sctp_conn)
 {
+  u8 i;
+  for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
+    {
+      if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
+	continue;
+
+      if (sctp_conn->sub_conn[i].is_retransmitting == 1 ||
+	  sctp_conn->sub_conn[i].enqueue_state != SCTP_ERROR_ENQUEUED)
+	{
+	  SCTP_DBG_OUTPUT
+	    ("Connection %u has still DATA to be enqueued inboud / outboud",
+	     sctp_conn->sub_conn[i].connection.c_index);
+	  return 1;
+	}
+
+    }
   return 0;			/* Indicates no more data to be read/sent */
 }
 
@@ -458,7 +573,7 @@ void
 sctp_connection_close (sctp_connection_t * sctp_conn)
 {
   SCTP_DBG ("Closing connection %u...",
-	    sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index);
+	    sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.c_index);
 
   sctp_conn->state = SCTP_STATE_SHUTDOWN_PENDING;
 
@@ -470,97 +585,76 @@ sctp_session_close (u32 conn_index, u32 thread_index)
 {
   ASSERT (thread_index == 0);
 
-  sctp_connection_t *sctp_conn;
-  sctp_conn = sctp_connection_get (conn_index, thread_index);
-  sctp_connection_close (sctp_conn);
+  sctp_connection_t *sctp_conn =
+    sctp_connection_get (conn_index, thread_index);
+  if (sctp_conn != NULL)
+    sctp_connection_close (sctp_conn);
 }
 
 void
 sctp_session_cleanup (u32 conn_index, u32 thread_index)
 {
-  sctp_connection_t *sctp_conn;
-  sctp_conn = sctp_connection_get (conn_index, thread_index);
-  sctp_connection_timers_reset (sctp_conn);
+  sctp_connection_t *sctp_conn =
+    sctp_connection_get (conn_index, thread_index);
 
-  /* Wait for the session tx events to clear */
-  sctp_conn->state = SCTP_STATE_CLOSED;
+  if (sctp_conn != NULL)
+    {
+      sctp_connection_timers_reset (sctp_conn);
+      /* Wait for the session tx events to clear */
+      sctp_conn->state = SCTP_STATE_CLOSED;
+    }
 }
 
 /**
- * Update snd_mss to reflect the effective segment size that we can send
+ * Compute maximum segment size for session layer.
  */
-void
-sctp_update_snd_mss (sctp_connection_t * sctp_conn)
-{
-  /* The overhead for the sctp_header_t and sctp_chunks_common_hdr_t
-   * (the sum equals to sctp_full_hdr_t) is already taken into account
-   * for the sctp_conn->a_rwnd computation.
-   * So let's not account it again here.
-   */
-  sctp_conn->snd_hdr_length =
-    sizeof (sctp_payload_data_chunk_t) - sizeof (sctp_full_hdr_t);
-  sctp_conn->snd_a_rwnd =
-    clib_min (sctp_conn->a_rwnd,
-	      sctp_conn->rcv_opts.a_rwnd) - sctp_conn->snd_hdr_length;
-
-  SCTP_DBG ("sctp_conn->snd_a_rwnd = %u, sctp_conn->snd_hdr_length = %u ",
-	    sctp_conn->snd_a_rwnd, sctp_conn->snd_hdr_length);
-
-  ASSERT (sctp_conn->snd_a_rwnd > 0);
-}
-
 u16
 sctp_session_send_mss (transport_connection_t * trans_conn)
 {
-  SCTP_DBG ("CONN_INDEX: %u", trans_conn->c_index);
-
   sctp_connection_t *sctp_conn =
     sctp_get_connection_from_transport (trans_conn);
 
-  if (trans_conn == NULL)
-    {
-      SCTP_DBG ("trans_conn == NULL");
-      return 0;
-    }
-
   if (sctp_conn == NULL)
     {
       SCTP_DBG ("sctp_conn == NULL");
       return 0;
     }
-  /* 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. */
-  sctp_update_snd_mss (sctp_conn);
 
-  return sctp_conn->snd_a_rwnd;
+  update_cwnd (sctp_conn);
+  update_smallest_pmtu_idx (sctp_conn);
+
+  u8 idx = sctp_data_subconn_select (sctp_conn);
+  return sctp_conn->sub_conn[idx].cwnd;
 }
 
 u16
 sctp_snd_space (sctp_connection_t * sctp_conn)
 {
-  /* TODO: This requires a real implementation */
-  if (sctp_conn == NULL)
-    {
-      SCTP_DBG ("sctp_conn == NULL");
-      return 0;
-    }
+  /* RFC 4096 Section 6.1; point (A) */
+  if (sctp_conn->peer_rwnd == 0)
+    return 0;
 
-  if (sctp_conn->state != SCTP_STATE_ESTABLISHED)
-    {
-      SCTP_DBG_STATE_MACHINE
-	("Trying to send DATA while not in SCTP_STATE_ESTABLISHED");
-      return 0;
-    }
+  u8 idx = sctp_data_subconn_select (sctp_conn);
+
+  u32 available_wnd =
+    clib_min (sctp_conn->peer_rwnd, sctp_conn->sub_conn[idx].cwnd);
+  int flight_size = (int) (sctp_conn->next_tsn - sctp_conn->last_unacked_tsn);
+
+  if (available_wnd <= flight_size)
+    return 0;
 
-  return sctp_conn->snd_a_rwnd;
+  /* Finally, let's subtract the DATA chunk headers overhead */
+  return available_wnd -
+    flight_size -
+    sizeof (sctp_payload_data_chunk_t) - sizeof (sctp_full_hdr_t);
 }
 
+/**
+ * Compute TX window session is allowed to fill.
+ */
 u32
 sctp_session_send_space (transport_connection_t * trans_conn)
 {
-  SCTP_DBG ("CONN_INDEX: %u", trans_conn->c_index);
-
   sctp_connection_t *sctp_conn =
     sctp_get_connection_from_transport (trans_conn);
 
@@ -572,7 +666,11 @@ sctp_session_get_transport (u32 conn_index, u32 thread_index)
 {
   sctp_connection_t *sctp_conn =
     sctp_connection_get (conn_index, thread_index);
-  return &sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection;
+
+  if (PREDICT_TRUE (sctp_conn != NULL))
+    return &sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection;
+
+  return NULL;
 }
 
 transport_connection_t *
@@ -581,59 +679,103 @@ sctp_session_get_listener (u32 listener_index)
   sctp_main_t *tm = vnet_get_sctp_main ();
   sctp_connection_t *sctp_conn;
   sctp_conn = pool_elt_at_index (tm->listener_pool, listener_index);
-  return &sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection;
+  return &sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection;
 }
 
 u8 *
 format_sctp_session (u8 * s, va_list * args)
 {
-  return NULL;
+  u32 tci = va_arg (*args, u32);
+  u32 thread_index = va_arg (*args, u32);
+  u32 verbose = va_arg (*args, u32);
+  sctp_connection_t *tc;
+
+  tc = sctp_connection_get (tci, thread_index);
+  if (tc)
+    s = format (s, "%U", format_sctp_connection, tc, verbose);
+  else
+    s = format (s, "empty\n");
+  return s;
 }
 
 u8 *
 format_sctp_listener_session (u8 * s, va_list * args)
 {
-  return NULL;
+  u32 tci = va_arg (*args, u32);
+  sctp_connection_t *tc = sctp_listener_get (tci);
+  return format (s, "%U", format_sctp_connection_id, tc);
 }
 
 void
-sctp_timer_init_handler (u32 conn_index, u32 timer_id)
+sctp_expired_timers_cb (u32 conn_index, u32 timer_id)
 {
   sctp_connection_t *sctp_conn;
 
-  clib_warning ("");
+  SCTP_DBG ("%s expired", sctp_timer_to_string (timer_id));
+
   sctp_conn = sctp_connection_get (conn_index, vlib_get_thread_index ());
   /* note: the connection may have already disappeared */
   if (PREDICT_FALSE (sctp_conn == 0))
     return;
-  ASSERT (sctp_conn->state == SCTP_STATE_COOKIE_ECHOED);
+
+  if (sctp_conn->sub_conn[conn_index].unacknowledged_hb >
+      SCTP_PATH_MAX_RETRANS)
+    {
+      // The remote-peer is considered to be unreachable hence shutting down
+      u8 i, total_subs_down = 1;
+      for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
+	{
+	  if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
+	    continue;
+
+	  u32 now = sctp_time_now ();
+	  if (now > (sctp_conn->sub_conn[i].last_seen + SCTP_HB_INTERVAL))
+	    {
+	      total_subs_down += 1;
+	      sctp_conn->sub_conn[i].state = SCTP_SUBCONN_STATE_DOWN;
+	    }
+	}
+
+      if (total_subs_down == MAX_SCTP_CONNECTIONS)
+	{
+	  /* Start cleanup. App wasn't notified yet so use delete notify as
+	   * opposed to delete to cleanup session layer state. */
+	  stream_session_delete_notify (&sctp_conn->sub_conn
+					[SCTP_PRIMARY_PATH_IDX].connection);
+
+	  sctp_connection_timers_reset (sctp_conn);
+
+	  sctp_connection_cleanup (sctp_conn);
+	}
+      return;
+    }
 
   switch (timer_id)
     {
+    case SCTP_TIMER_T1_INIT:
+      sctp_send_init (sctp_conn);
+      break;
+    case SCTP_TIMER_T1_COOKIE:
+      sctp_send_cookie_echo (sctp_conn);
+      break;
+    case SCTP_TIMER_T2_SHUTDOWN:
+      sctp_send_shutdown (sctp_conn);
+      break;
+    case SCTP_TIMER_T3_RXTX:
+      sctp_timer_reset (sctp_conn, conn_index, timer_id);
+      sctp_conn->flags |= SCTP_CONN_RECOVERY;
+      sctp_data_retransmit (sctp_conn);
+      break;
     case SCTP_TIMER_T4_HEARTBEAT:
-      {
-	clib_warning ("Heartbeat timeout");
-	break;
-      }
+      sctp_timer_reset (sctp_conn, conn_index, timer_id);
+      goto heartbeat;
     }
-  /* Start cleanup. App wasn't notified yet so use delete notify as
-   * opposed to delete to cleanup session layer state. */
-  stream_session_delete_notify (&sctp_conn->
-				sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection);
-
-  sctp_connection_timers_reset (sctp_conn);
+  return;
 
-  sctp_connection_cleanup (sctp_conn);
+heartbeat:
+  sctp_send_heartbeat (sctp_conn);
 }
 
-/* *INDENT OFF* */
-static sctp_timer_expiration_handler
-  * sctp_timer_expiration_handlers[SCTP_N_TIMERS] = {
-  sctp_timer_init_handler
-};
-
-/* *INDENT ON* */
-
 static void
 sctp_expired_timers_dispatch (u32 * expired_timers)
 {
@@ -646,12 +788,11 @@ sctp_expired_timers_dispatch (u32 * expired_timers)
       connection_index = expired_timers[i] & 0x0FFFFFFF;
       timer_id = expired_timers[i] >> 28;
 
+      SCTP_DBG ("Expired timer ID: %u", timer_id);
+
       /* Handle expiration */
-      (*sctp_timer_expiration_handlers[timer_id]) (connection_index,
-						   timer_id);
+      sctp_expired_timers_cb (connection_index, timer_id);
     }
-
-  clib_warning ("");
 }
 
 void
@@ -736,6 +877,7 @@ sctp_main_enable (vlib_main_t * vm)
 
   if (num_threads > 1)
     {
+      clib_spinlock_init (&tm->half_open_lock);
     }
 
   vec_validate (tm->tx_frames[0], num_threads - 1);
@@ -772,7 +914,7 @@ transport_connection_t *
 sctp_half_open_session_get_transport (u32 conn_index)
 {
   sctp_connection_t *sctp_conn = sctp_half_open_connection_get (conn_index);
-  return &sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection;
+  return &sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection;
 }
 
 u8 *
@@ -783,6 +925,15 @@ format_sctp_half_open (u8 * s, va_list * args)
   return format (s, "%U", format_sctp_connection_id, sctp_conn);
 }
 
+void
+sctp_update_time (f64 now, u8 thread_index)
+{
+  sctp_set_time_now (thread_index);
+  tw_timer_expire_timers_16t_2w_512sl (&sctp_main.timer_wheels[thread_index],
+				       now);
+  sctp_flush_frames_to_output (thread_index);
+}
+
 /* *INDENT OFF* */
 const static transport_proto_vft_t sctp_proto = {
   .enable = sctp_enable_disable,
@@ -794,13 +945,15 @@ const static transport_proto_vft_t sctp_proto = {
   .push_header = sctp_push_header,
   .send_mss = sctp_session_send_mss,
   .send_space = sctp_session_send_space,
-  .tx_fifo_offset = NULL,	//sctp_session_tx_fifo_offset,
+  .update_time = sctp_update_time,
   .get_connection = sctp_session_get_transport,
   .get_listener = sctp_session_get_listener,
   .get_half_open = sctp_half_open_session_get_transport,
   .format_connection = format_sctp_session,
   .format_listener = format_sctp_listener_session,
   .format_half_open = format_sctp_half_open,
+  .tx_type = TRANSPORT_TX_DEQUEUE,
+  .service_type = TRANSPORT_SERVICE_VC,
 };
 
 /* *INDENT ON* */
@@ -827,6 +980,8 @@ sctp_init (vlib_main_t * vm)
   transport_register_protocol (TRANSPORT_PROTO_SCTP, &sctp_proto,
 			       FIB_PROTOCOL_IP6, sctp6_output_node.index);
 
+  sctp_api_reference ();
+
   return 0;
 }