Prep-work patch for congestion-control

This patch addresses the missing field in various data-structures to
track valuable information to implement the congestion-control
algorithms and manage sub-connections states.

It adds the possibility to queue up to 2 SACKs chunks when the connection
is not gapping.

At the same time, it pushes some variable/field renaming for better
readibility.

Change-Id: Idcc53512983456779600a75e78e21af078e46602
Signed-off-by: Marco Varlese <marco.varlese@suse.de>

6 files changed, 670 insertions, 450 deletions

diff --git a/src/vnet/sctp/sctp.c b/src/vnet/sctp/sctp.c
index 2e37a91dbac..d0f37f4346e 100644
--- a/src/vnet/sctp/sctp.c
+++ b/src/vnet/sctp/sctp.c
@@ -65,13 +65,13 @@ static void
 sctp_connection_unbind (u32 listener_index)
 {
   sctp_main_t *tm = vnet_get_sctp_main ();
-  sctp_connection_t *tc;
+  sctp_connection_t *sctp_conn;
 
-  tc = pool_elt_at_index (tm->listener_pool, listener_index);
+  sctp_conn = pool_elt_at_index (tm->listener_pool, listener_index);
 
   /* Poison the entry */
   if (CLIB_DEBUG > 0)
-    memset (tc, 0xFA, sizeof (*tc));
+    memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
 
   pool_put_index (tm->listener_pool, listener_index);
 }
@@ -127,31 +127,32 @@ sctp_alloc_custom_local_endpoint (sctp_main_t * tm, ip46_address_t * lcl_addr,
  * Initialize all connection timers as invalid
  */
 void
-sctp_connection_timers_init (sctp_connection_t * tc)
+sctp_connection_timers_init (sctp_connection_t * sctp_conn)
 {
   int i, j;
 
   /* Set all to invalid */
   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
-    for (j = 0; j < SCTP_N_TIMERS; j++)
-      {
-	tc->sub_conn[i].timers[j] = SCTP_TIMER_HANDLE_INVALID;
-      }
-
-  tc->rto = SCTP_RTO_INIT;
+    {
+      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;
+	}
+    }
 }
 
 /**
  * Stop all connection timers
  */
 void
-sctp_connection_timers_reset (sctp_connection_t * tc)
+sctp_connection_timers_reset (sctp_connection_t * sctp_conn)
 {
   int i, j;
   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
     {
       for (j = 0; j < SCTP_N_TIMERS; j++)
-	sctp_timer_reset (tc, i, j);
+	sctp_timer_reset (sctp_conn, i, j);
     }
 }
 
@@ -177,22 +178,22 @@ u8 *
 format_sctp_connection_id (u8 * s, va_list * args)
 {
   /*
-     sctp_connection_t *tc = va_arg (*args, sctp_connection_t *);
-     if (!tc)
+     sctp_connection_t *sctp_conn = va_arg (*args, sctp_connection_t *);
+     if (!sctp_conn)
      return s;
-     if (tc->c_is_ip4)
+     if (sctp_conn->c_is_ip4)
      {
-     s = format (s, "[#%d][%s] %U:%d->%U:%d", tc->c_thread_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));
+     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", tc->c_thread_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));
+     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));
      }
    */
   return s;
@@ -201,15 +202,15 @@ format_sctp_connection_id (u8 * s, va_list * args)
 u8 *
 format_sctp_connection (u8 * s, va_list * args)
 {
-  sctp_connection_t *tc = va_arg (*args, sctp_connection_t *);
+  sctp_connection_t *sctp_conn = va_arg (*args, sctp_connection_t *);
   u32 verbose = va_arg (*args, u32);
 
-  if (!tc)
+  if (!sctp_conn)
     return s;
-  s = format (s, "%-50U", format_sctp_connection_id, tc);
+  s = format (s, "%-50U", format_sctp_connection_id, sctp_conn);
   if (verbose)
     {
-      s = format (s, "%-15U", format_sctp_state, tc->state);
+      s = format (s, "%-15U", format_sctp_state, sctp_conn->state);
     }
 
   return s;
@@ -219,23 +220,23 @@ format_sctp_connection (u8 * s, va_list * args)
  * Initialize connection send variables.
  */
 void
-sctp_init_snd_vars (sctp_connection_t * tc)
+sctp_init_snd_vars (sctp_connection_t * sctp_conn)
 {
   u32 time_now;
-
   /*
    * 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.
    */
+
   sctp_set_time_now (vlib_get_thread_index ());
   time_now = sctp_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;
+  sctp_conn->local_initial_tsn = random_u32 (&time_now);
+  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;
 }
 
 /**
@@ -245,72 +246,63 @@ sctp_init_snd_vars (sctp_connection_t * tc)
  * also what we advertise to our peer.
  */
 void
-sctp_update_rcv_mss (sctp_connection_t * tc)
+sctp_update_rcv_mss (sctp_connection_t * sctp_conn)
 {
-  /* TODO find our iface MTU */
-  tc->a_rwnd = DEFAULT_A_RWND - sizeof (sctp_full_hdr_t);
-  tc->rcv_opts.a_rwnd = tc->a_rwnd;
-  tc->rcv_a_rwnd = tc->a_rwnd;	/* This will be updated by our congestion algos */
+  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 */
 }
 
 void
-sctp_init_mss (sctp_connection_t * tc)
+sctp_init_mss (sctp_connection_t * sctp_conn)
 {
   SCTP_DBG ("CONN_INDEX = %u",
-	    tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index);
+	    sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index);
 
   u16 default_a_rwnd = 536;
-  sctp_update_rcv_mss (tc);
+  sctp_update_rcv_mss (sctp_conn);
 
   /* TODO cache mss and consider PMTU discovery */
-  tc->snd_a_rwnd = clib_min (tc->rcv_opts.a_rwnd, tc->a_rwnd);
+  sctp_conn->snd_a_rwnd =
+    clib_min (sctp_conn->rcv_opts.a_rwnd, sctp_conn->a_rwnd);
 
-  if (tc->snd_a_rwnd < sizeof (sctp_full_hdr_t))
+  if (sctp_conn->snd_a_rwnd < sizeof (sctp_full_hdr_t))
     {
-      SCTP_ADV_DBG ("tc->snd_a_rwnd < sizeof(sctp_full_hdr_t)");
+      SCTP_ADV_DBG ("sctp_conn->snd_a_rwnd < sizeof(sctp_full_hdr_t)");
       /* Assume that at least the min default mss works */
-      tc->snd_a_rwnd = default_a_rwnd;
-      tc->rcv_opts.a_rwnd = default_a_rwnd;
+      sctp_conn->snd_a_rwnd = default_a_rwnd;
+      sctp_conn->rcv_opts.a_rwnd = default_a_rwnd;
     }
 
-  ASSERT (tc->snd_a_rwnd > sizeof (sctp_full_hdr_t));
-}
-
-/** Initialize sctp connection variables
- *
- * Should be called after having received a msg from the peer, i.e., a SYN or
- * a SYNACK, such that connection options have already been exchanged. */
-void
-sctp_connection_init_vars (sctp_connection_t * tc)
-{
-  sctp_init_mss (tc);
-  sctp_init_snd_vars (tc);
+  ASSERT (sctp_conn->snd_a_rwnd > sizeof (sctp_full_hdr_t));
 }
 
 always_inline sctp_connection_t *
 sctp_sub_connection_add (u8 thread_index)
 {
   sctp_main_t *tm = vnet_get_sctp_main ();
-  sctp_connection_t *tc = tm->connections[thread_index];
+  sctp_connection_t *sctp_conn = tm->connections[thread_index];
 
-  tc->sub_conn[tc->next_avail_sub_conn].connection.c_index =
-    tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index;
-  tc->sub_conn[tc->next_avail_sub_conn].connection.thread_index =
-    thread_index;
-  tc->sub_conn[tc->next_avail_sub_conn].parent = tc;
+  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;
 
-  tc->next_avail_sub_conn += 1;
+  sctp_conn->next_avail_sub_conn += 1;
 
-  return tc;
+  return sctp_conn;
 }
 
 void
 sctp_sub_connection_add_ip4 (u8 thread_index,
 			     sctp_ipv4_addr_param_t * ipv4_addr)
 {
-  sctp_connection_t *tc = sctp_sub_connection_add (thread_index);
+  sctp_connection_t *sctp_conn = sctp_sub_connection_add (thread_index);
 
-  clib_memcpy (&tc->sub_conn[tc->next_avail_sub_conn].connection.lcl_ip.ip4,
+  clib_memcpy (&sctp_conn->
+	       sub_conn[sctp_conn->next_avail_sub_conn].connection.lcl_ip.ip4,
 	       &ipv4_addr->address, sizeof (ipv4_addr->address));
 }
 
@@ -318,9 +310,10 @@ void
 sctp_sub_connection_add_ip6 (u8 thread_index,
 			     sctp_ipv6_addr_param_t * ipv6_addr)
 {
-  sctp_connection_t *tc = sctp_sub_connection_add (thread_index);
+  sctp_connection_t *sctp_conn = sctp_sub_connection_add (thread_index);
 
-  clib_memcpy (&tc->sub_conn[tc->next_avail_sub_conn].connection.lcl_ip.ip6,
+  clib_memcpy (&sctp_conn->
+	       sub_conn[sctp_conn->next_avail_sub_conn].connection.lcl_ip.ip6,
 	       &ipv6_addr->address, sizeof (ipv6_addr->address));
 }
 
@@ -328,39 +321,39 @@ sctp_connection_t *
 sctp_connection_new (u8 thread_index)
 {
   sctp_main_t *tm = vnet_get_sctp_main ();
-  sctp_connection_t *tc;
+  sctp_connection_t *sctp_conn;
 
-  pool_get (tm->connections[thread_index], tc);
-  memset (tc, 0, sizeof (*tc));
-  tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = tc;
-  tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index =
-    tc - tm->connections[thread_index];
-  tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_thread_index = thread_index;
-  tc->local_tag = 0;
-  tc->next_avail_sub_conn = 1;
+  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;
+  sctp_conn->local_tag = 0;
+  sctp_conn->next_avail_sub_conn = 1;
 
-  return tc;
+  return sctp_conn;
 }
 
 sctp_connection_t *
 sctp_half_open_connection_new (u8 thread_index)
 {
   sctp_main_t *tm = vnet_get_sctp_main ();
-  sctp_connection_t *tc = 0;
+  sctp_connection_t *sctp_conn = 0;
   ASSERT (vlib_get_thread_index () == 0);
-  pool_get (tm->half_open_connections, tc);
-  memset (tc, 0, sizeof (*tc));
-  tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index =
-    tc - tm->half_open_connections;
-  tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = tc;
-  return tc;
+  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 =
+    sctp_conn - tm->half_open_connections;
+  sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = sctp_conn;
+  return sctp_conn;
 }
 
 static inline int
 sctp_connection_open (transport_endpoint_t * rmt)
 {
   sctp_main_t *tm = vnet_get_sctp_main ();
-  sctp_connection_t *tc;
+  sctp_connection_t *sctp_conn;
   ip46_address_t lcl_addr;
   u16 lcl_port;
   uword thread_id;
@@ -389,27 +382,27 @@ sctp_connection_open (transport_endpoint_t * rmt)
   ASSERT (thread_id == 0);
 
   clib_spinlock_lock_if_init (&tm->half_open_lock);
-  tc = sctp_half_open_connection_new (thread_id);
-
-  transport_connection_t *t_conn = &tc->sub_conn[idx].connection;
-  ip_copy (&t_conn->rmt_ip, &rmt->ip, rmt->is_ip4);
-  ip_copy (&t_conn->lcl_ip, &lcl_addr, rmt->is_ip4);
-  tc->sub_conn[idx].parent = tc;
-  t_conn->rmt_port = rmt->port;
-  t_conn->lcl_port = clib_host_to_net_u16 (lcl_port);
-  t_conn->is_ip4 = rmt->is_ip4;
-  t_conn->proto = TRANSPORT_PROTO_SCTP;
-  t_conn->fib_index = rmt->fib_index;
-
-  sctp_connection_timers_init (tc);
+  sctp_conn = sctp_half_open_connection_new (thread_id);
+
+  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;
+  trans_conn->rmt_port = rmt->port;
+  trans_conn->lcl_port = clib_host_to_net_u16 (lcl_port);
+  trans_conn->is_ip4 = rmt->is_ip4;
+  trans_conn->proto = TRANSPORT_PROTO_SCTP;
+  trans_conn->fib_index = rmt->fib_index;
+
+  sctp_connection_timers_init (sctp_conn);
   /* The other connection vars will be initialized after INIT_ACK chunk received */
-  sctp_init_snd_vars (tc);
+  sctp_init_snd_vars (sctp_conn);
 
-  sctp_send_init (tc);
+  sctp_send_init (sctp_conn);
 
   clib_spinlock_unlock_if_init (&tm->half_open_lock);
 
-  return tc->sub_conn[idx].connection.c_index;
+  return sctp_conn->sub_conn[idx].connection.c_index;
 }
 
 /**
@@ -418,7 +411,7 @@ sctp_connection_open (transport_endpoint_t * rmt)
  * No notifications.
  */
 void
-sctp_connection_cleanup (sctp_connection_t * tc)
+sctp_connection_cleanup (sctp_connection_t * sctp_conn)
 {
   sctp_main_t *tm = &sctp_main;
   u8 i;
@@ -426,26 +419,26 @@ sctp_connection_cleanup (sctp_connection_t * tc)
   /* Cleanup local endpoint if this was an active connect */
   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
     transport_endpoint_cleanup (TRANSPORT_PROTO_SCTP,
-				&tc->sub_conn[i].connection.lcl_ip,
-				tc->sub_conn[i].connection.lcl_port);
+				&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 (tc->state == SCTP_STATE_COOKIE_WAIT)
+  if (sctp_conn->state == SCTP_STATE_COOKIE_WAIT)
     {
 
     }
   else
     {
       int thread_index =
-	tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.thread_index;
+	sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.thread_index;
 
       /* Make sure all timers are cleared */
-      sctp_connection_timers_reset (tc);
+      sctp_connection_timers_reset (sctp_conn);
 
       /* Poison the entry */
       if (CLIB_DEBUG > 0)
-	memset (tc, 0xFA, sizeof (*tc));
-      pool_put (tm->connections[thread_index], tc);
+	memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
+      pool_put (tm->connections[thread_index], sctp_conn);
     }
 }
 
@@ -456,20 +449,20 @@ sctp_session_open (transport_endpoint_t * tep)
 }
 
 u16
-sctp_check_outstanding_data_chunks (sctp_connection_t * tc)
+sctp_check_outstanding_data_chunks (sctp_connection_t * sctp_conn)
 {
   return 0;			/* Indicates no more data to be read/sent */
 }
 
 void
-sctp_connection_close (sctp_connection_t * tc)
+sctp_connection_close (sctp_connection_t * sctp_conn)
 {
   SCTP_DBG ("Closing connection %u...",
-	    tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index);
+	    sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index);
 
-  tc->state = SCTP_STATE_SHUTDOWN_PENDING;
+  sctp_conn->state = SCTP_STATE_SHUTDOWN_PENDING;
 
-  sctp_send_shutdown (tc);
+  sctp_send_shutdown (sctp_conn);
 }
 
 void
@@ -477,42 +470,43 @@ sctp_session_close (u32 conn_index, u32 thread_index)
 {
   ASSERT (thread_index == 0);
 
-  sctp_connection_t *tc;
-  tc = sctp_connection_get (conn_index, thread_index);
-  sctp_connection_close (tc);
+  sctp_connection_t *sctp_conn;
+  sctp_conn = sctp_connection_get (conn_index, thread_index);
+  sctp_connection_close (sctp_conn);
 }
 
 void
 sctp_session_cleanup (u32 conn_index, u32 thread_index)
 {
-  sctp_connection_t *tc;
-  tc = sctp_connection_get (conn_index, thread_index);
-  sctp_connection_timers_reset (tc);
+  sctp_connection_t *sctp_conn;
+  sctp_conn = sctp_connection_get (conn_index, thread_index);
+  sctp_connection_timers_reset (sctp_conn);
 
   /* Wait for the session tx events to clear */
-  tc->state = SCTP_STATE_CLOSED;
+  sctp_conn->state = SCTP_STATE_CLOSED;
 }
 
 /**
  * Update snd_mss to reflect the effective segment size that we can send
  */
 void
-sctp_update_snd_mss (sctp_connection_t * tc)
+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 tc->a_rwnd computation.
+   * for the sctp_conn->a_rwnd computation.
    * So let's not account it again here.
    */
-  tc->snd_hdr_length =
+  sctp_conn->snd_hdr_length =
     sizeof (sctp_payload_data_chunk_t) - sizeof (sctp_full_hdr_t);
-  tc->snd_a_rwnd =
-    clib_min (tc->a_rwnd, tc->rcv_opts.a_rwnd) - tc->snd_hdr_length;
+  sctp_conn->snd_a_rwnd =
+    clib_min (sctp_conn->a_rwnd,
+	      sctp_conn->rcv_opts.a_rwnd) - sctp_conn->snd_hdr_length;
 
-  SCTP_DBG ("tc->snd_a_rwnd = %u, tc->snd_hdr_length = %u ",
-	    tc->snd_a_rwnd, tc->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 (tc->snd_a_rwnd > 0);
+  ASSERT (sctp_conn->snd_a_rwnd > 0);
 }
 
 u16
@@ -520,7 +514,8 @@ sctp_session_send_mss (transport_connection_t * trans_conn)
 {
   SCTP_DBG ("CONN_INDEX: %u", trans_conn->c_index);
 
-  sctp_connection_t *tc = sctp_get_connection_from_transport (trans_conn);
+  sctp_connection_t *sctp_conn =
+    sctp_get_connection_from_transport (trans_conn);
 
   if (trans_conn == NULL)
     {
@@ -528,17 +523,17 @@ sctp_session_send_mss (transport_connection_t * trans_conn)
       return 0;
     }
 
-  if (tc == NULL)
+  if (sctp_conn == NULL)
     {
-      SCTP_DBG ("tc == 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 (tc);
+  sctp_update_snd_mss (sctp_conn);
 
-  return tc->snd_a_rwnd;
+  return sctp_conn->snd_a_rwnd;
 }
 
 u16
@@ -566,42 +561,27 @@ sctp_session_send_space (transport_connection_t * trans_conn)
 {
   SCTP_DBG ("CONN_INDEX: %u", trans_conn->c_index);
 
-  sctp_connection_t *tc = sctp_get_connection_from_transport (trans_conn);
-
-  return sctp_snd_space (tc);
-}
-
-u32
-sctp_session_tx_fifo_offset (transport_connection_t * trans_conn)
-{
-  SCTP_DBG ("CONN_INDEX: %u", trans_conn->c_index);
-
-  sctp_connection_t *tc = sctp_get_connection_from_transport (trans_conn);
+  sctp_connection_t *sctp_conn =
+    sctp_get_connection_from_transport (trans_conn);
 
-  if (tc == NULL)
-    {
-      SCTP_DBG ("tc == NULL");
-      return 0;
-    }
-
-  /* This still works if fast retransmit is on */
-  return (tc->snd_nxt - tc->snd_una);
+  return sctp_snd_space (sctp_conn);
 }
 
 transport_connection_t *
 sctp_session_get_transport (u32 conn_index, u32 thread_index)
 {
-  sctp_connection_t *tc = sctp_connection_get (conn_index, thread_index);
-  return &tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection;
+  sctp_connection_t *sctp_conn =
+    sctp_connection_get (conn_index, thread_index);
+  return &sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection;
 }
 
 transport_connection_t *
 sctp_session_get_listener (u32 listener_index)
 {
   sctp_main_t *tm = vnet_get_sctp_main ();
-  sctp_connection_t *tc;
-  tc = pool_elt_at_index (tm->listener_pool, listener_index);
-  return &tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection;
+  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;
 }
 
 u8 *
@@ -617,28 +597,38 @@ format_sctp_listener_session (u8 * s, va_list * args)
 }
 
 void
-sctp_timer_init_handler (u32 conn_index)
+sctp_timer_init_handler (u32 conn_index, u32 timer_id)
 {
-  sctp_connection_t *tc;
+  sctp_connection_t *sctp_conn;
 
-  tc = sctp_connection_get (conn_index, vlib_get_thread_index ());
+  clib_warning ("");
+  sctp_conn = sctp_connection_get (conn_index, vlib_get_thread_index ());
   /* note: the connection may have already disappeared */
-  if (PREDICT_FALSE (tc == 0))
+  if (PREDICT_FALSE (sctp_conn == 0))
     return;
-  ASSERT (tc->state == SCTP_STATE_COOKIE_ECHOED);
+  ASSERT (sctp_conn->state == SCTP_STATE_COOKIE_ECHOED);
+
+  switch (timer_id)
+    {
+    case SCTP_TIMER_T4_HEARTBEAT:
+      {
+	clib_warning ("Heartbeat timeout");
+	break;
+      }
+    }
   /* Start cleanup. App wasn't notified yet so use delete notify as
    * opposed to delete to cleanup session layer state. */
-  stream_session_delete_notify (&tc->
+  stream_session_delete_notify (&sctp_conn->
 				sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection);
-  tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].timers[SCTP_TIMER_T1_INIT] =
-    SCTP_TIMER_HANDLE_INVALID;
 
-  sctp_connection_cleanup (tc);
+  sctp_connection_timers_reset (sctp_conn);
+
+  sctp_connection_cleanup (sctp_conn);
 }
 
 /* *INDENT OFF* */
-static timer_expiration_handler *sctp_timer_expiration_handlers[SCTP_N_TIMERS]
-  = {
+static sctp_timer_expiration_handler
+  * sctp_timer_expiration_handlers[SCTP_N_TIMERS] = {
   sctp_timer_init_handler
 };
 
@@ -657,8 +647,11 @@ sctp_expired_timers_dispatch (u32 * expired_timers)
       timer_id = expired_timers[i] >> 28;
 
       /* Handle expiration */
-      (*sctp_timer_expiration_handlers[timer_id]) (connection_index);
+      (*sctp_timer_expiration_handlers[timer_id]) (connection_index,
+						   timer_id);
     }
+
+  clib_warning ("");
 }
 
 void
@@ -683,7 +676,7 @@ sctp_main_enable (vlib_main_t * vm)
   clib_error_t *error = 0;
   u32 num_threads;
   int thread;
-  sctp_connection_t *tc __attribute__ ((unused));
+  sctp_connection_t *sctp_conn __attribute__ ((unused));
   u32 preallocated_connections_per_thread;
 
   if ((error = vlib_call_init_function (vm, ip_main_init)))
@@ -778,16 +771,16 @@ sctp_enable_disable (vlib_main_t * vm, u8 is_en)
 transport_connection_t *
 sctp_half_open_session_get_transport (u32 conn_index)
 {
-  sctp_connection_t *tc = sctp_half_open_connection_get (conn_index);
-  return &tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection;
+  sctp_connection_t *sctp_conn = sctp_half_open_connection_get (conn_index);
+  return &sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection;
 }
 
 u8 *
 format_sctp_half_open (u8 * s, va_list * args)
 {
   u32 tci = va_arg (*args, u32);
-  sctp_connection_t *tc = sctp_half_open_connection_get (tci);
-  return format (s, "%U", format_sctp_connection_id, tc);
+  sctp_connection_t *sctp_conn = sctp_half_open_connection_get (tci);
+  return format (s, "%U", format_sctp_connection_id, sctp_conn);
 }
 
 /* *INDENT OFF* */
diff --git a/src/vnet/sctp/sctp.h b/src/vnet/sctp/sctp.h
index 7c4df309906..3e3750ea92a 100644
--- a/src/vnet/sctp/sctp.h
+++ b/src/vnet/sctp/sctp.h
@@ -28,6 +28,7 @@
   _(T1_COOKIE, "T1_COOKIE")        			\
   _(T2_SHUTDOWN, "T2_SHUTDOWN")         	\
   _(T3_RXTX, "T3_RXTX")   					\
+  _(T4_HEARTBEAT, "T4_HB")					\
   _(T5_SHUTDOWN_GUARD, "T5_SHUTDOWN_GUARD")
 
 typedef enum _sctp_timers
@@ -71,58 +72,125 @@ typedef struct _sctp_sub_connection
 {
   transport_connection_t connection;	      /**< Common transport data. First! */
   void *parent;								/**< Link to the parent-super connection */
-  u32 timers[SCTP_N_TIMERS];		/**< Timer handles into timer wheel */
+
+  u32 error_count; /**< The current error count for this destination. */
+  u32 error_threshold; /**< Current error threshold for this destination,
+				i.e. what value marks the destination down if error count reaches this value. */
+  u32 cwnd; /**< The current congestion window. */
+  u32 ssthresh;	/**< The current ssthresh value. */
+
+  u32 RTO; /**< The current retransmission timeout value. */
+  u32 SRTT; /**< The current smoothed round-trip time. */
+  u32 RTTVAR; /**< The current RTT variation. */
+
+  u32 partially_acked_bytes; /**< The tracking method for increase of cwnd when in
+  	  	  	  	  congestion avoidance mode (see Section 7.2.2).*/
+
+  u8 state; /**< The current state of this destination, i.e., DOWN, UP, ALLOW-HB, NO-HEARTBEAT, etc. */
+
+  u16 PMTU; /**< The current known path MTU. */
+
+  u32 timers[SCTP_N_TIMERS]; /**< A timer used by each destination. */
+
+  u8 RTO_pending; /**< A flag used to track if one of the DATA chunks sent to
+  	  	  	  	  this address is currently being used to compute an RTT.
+  	  	  	  	  If this flag is 0, the next DATA chunk sent to this destination
+  	  	  	  	  should be used to compute an RTT and this flag should be set.
+  	  	  	  	  Every time the RTT calculation completes (i.e., the DATA chunk is SACK'd),
+  	  	  	  	  clear this flag. */
+
+  u32 last_time; /**< The time to which this destination was last sent a packet to.
+  	  	  	  	  This can be used to determine if a HEARTBEAT is needed. */
 
 } sctp_sub_connection_t;
 
 typedef struct
 {
-  u32 a_rwnd;		/**< Maximum segment size advertised */
+  u32 a_rwnd; /**< Maximum segment size advertised */
 
 } sctp_options_t;
 
+#define SetBit(A,k)     ( A[(k/32)] |= (1 << (k%32)) )
+#define ClearBit(A,k)   ( A[(k/32)] &= ~(1 << (k%32)) )
+#define TestBit(A,k)    ( A[(k/32)] & (1 << (k%32)) )
+
+#define MAX_INFLIGHT_PACKETS	128
+#define MAX_ENQUEABLE_SACKS 2
+
+/* This parameter indicates to the receiver how much increment in
+ * milliseconds the sender wishes the receiver to add to its default
+ * cookie life-span.
+ */
+#define SUGGESTED_COOKIE_LIFE_SPAN_INCREMENT 1000
+
 typedef struct _sctp_connection
 {
-  sctp_sub_connection_t sub_conn[MAX_SCTP_CONNECTIONS];	       /**< Common transport data. First! */
+  sctp_sub_connection_t sub_conn[MAX_SCTP_CONNECTIONS];	/**< Common transport data. First! */
 
   u8 state;			/**< SCTP state as per sctp_state_t */
   u16 flags;		/**< Chunk flag (see sctp_chunks_common_hdr_t) */
+
   u32 local_tag;	/**< INIT_TAG generated locally */
   u32 remote_tag;	/**< INIT_TAG generated by the remote peer */
-  u16 life_span_inc;
-
-  /** Send sequence variables RFC4960 */
-  u32 snd_una;		/**< oldest unacknowledged sequence number */
-  u32 snd_una_max;	/**< newest unacknowledged sequence number + 1*/
-  u32 snd_wl1;		/**< seq number used for last snd.wnd update */
-  u32 snd_wl2;		/**< ack number used for last snd.wnd update */
-  u32 snd_nxt;		/**< next seq number to be sent */
-
-  /** Receive sequence variables RFC4960 */
-  u32 rcv_nxt;		/**< next sequence number expected */
-  u32 rcv_las;		/**< rcv_nxt at last ack sent/rcv_wnd update */
-  u32 iss;		/**< initial sent sequence */
-  u32 irs;		/**< initial remote sequence */
-
-  /* RTT and RTO */
-  u32 rto;		/**< Retransmission timeout */
-  u32 rto_boff;		/**< Index for RTO backoff */
-  u32 srtt;		/**< Smoothed RTT */
-  u32 rttvar;		/**< Smoothed mean RTT difference. Approximates variance */
-  u32 rtt_ts;		/**< Timestamp for tracked ACK */
-  u32 rtt_seq;		/**< Sequence number for tracked ACK */
-
-  u32 a_rwnd;			/** Constrained by medium / IP / etc. */
+
+  u32 local_initial_tsn; /**< Initial TSN generated locally */
+  u32 remote_initial_tsn; /**< Initial TSN generated by the remote-peer */
+
+  u32 peer_cookie_life_span_increment;
+
+  u32 overall_err_count; /**< The overall association error count. */
+  u32 overall_err_treshold; /**< The threshold for this association that if the Overall Error Count
+  	  	  	  	  reaches will cause this association to be torn down. */
+
+  u32 peer_rwnd; /**< Current calculated value of the peer's rwnd. */
+
+  u32 next_tsn;	/**< The next TSN number to be assigned to a new DATA chunk.
+                 This is sent in the INIT or INIT ACK chunk to the peer
+                 and incremented each time a DATA chunk is assigned a
+                 TSN (normally just prior to transmit or during
+                 fragmentation). */
+
+  u32 next_tsn_expected; /**< The next TSN number expected to be received. */
+
+  u32 last_rcvd_tsn; /**< This is the last TSN received in sequence. This value
+     	 	 	 is set initially by taking the peer's initial TSN,
+                 received in the INIT or INIT ACK chunk, and
+                 subtracting one from it. */
+
+  u32 out_of_order_map[MAX_INFLIGHT_PACKETS]; /**< An array of bits or bytes indicating which out-of-order
+				TSNs have been received (relative to the Last Rcvd TSN).
+				If no gaps exist, i.e., no out-of-order packets have been received,
+				this array will be set to all zero. */
+
+  u8 ack_state;	/**< This flag indicates if the next received packet is set to be responded to with a SACK.
+  	  	  	  	This is initialized to 0. When a packet is received it is incremented.
+  	  	  	  	If this value reaches 2 or more, a SACK is sent and the value is reset to 0.
+  	  	  	  	Note: This is used only when no DATA chunks are received out-of-order.
+  	  	  	  	When DATA chunks are out-of-order, SACKs are not delayed (see Section 6). */
+
+  u32 a_rwnd; /** This value represents the dedicated buffer space, in number of bytes,
+				the sender of the INIT has reserved in association with this window.
+				During the life of the association, this buffer space SHOULD NOT be lessened
+				(i.e., dedicated buffers taken away from this association);
+				however, an endpoint MAY change the value of a_rwnd it sends in SACK chunks. */
+
+  u32 smallest_PMTU; /** The smallest PMTU discovered for all of the peer's transport addresses. */
+
   u32 rcv_a_rwnd;		/**< LOCAL max seg size that includes options. To be updated by congestion algos, etc. */
   u32 snd_a_rwnd;		/**< REMOTE max seg size that includes options. To be updated if peer pushes back on window, etc.*/
+
+  u32 rtt_ts;
+  u32 rtt_seq;
+
   sctp_options_t rcv_opts;
   sctp_options_t snd_opts;
-  u32 snd_hdr_length;	/**< BASE HEADER LENGTH for the DATA chunk when sending */
 
+  u32 snd_hdr_length;	/**< BASE HEADER LENGTH for the DATA chunk when sending */
   u8 next_avail_sub_conn; /**< Represent the index of the next free slot in sub_conn */
+
 } sctp_connection_t;
 
-typedef void (timer_expiration_handler) (u32 index);
+typedef void (sctp_timer_expiration_handler) (u32 conn_index, u32 timer_id);
 
 sctp_connection_t *sctp_connection_new (u8 thread_index);
 void sctp_sub_connection_add_ip4 (u8 thread_index,
@@ -155,7 +223,7 @@ clib_error_t *sctp_init (vlib_main_t * vm);
 void sctp_connection_timers_init (sctp_connection_t * tc);
 void sctp_connection_timers_reset (sctp_connection_t * tc);
 void sctp_init_snd_vars (sctp_connection_t * tc);
-void sctp_connection_init_vars (sctp_connection_t * tc);
+void sctp_init_mss (sctp_connection_t * tc);
 
 void sctp_prepare_initack_chunk (sctp_connection_t * ts, vlib_buffer_t * b,
 				 ip4_address_t * ip4_addr,
@@ -522,6 +590,7 @@ sctp_timer_update (sctp_connection_t * tc, u8 conn_idx, u8 timer_id,
   if (tc->sub_conn[conn_idx].timers[timer_id] != SCTP_TIMER_HANDLE_INVALID)
     tw_timer_stop_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 				sub->timers[timer_id]);
+
   tc->sub_conn[conn_idx].timers[timer_id] =
     tw_timer_start_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 				 sub->c_c_index, timer_id, interval);
diff --git a/src/vnet/sctp/sctp_debug.h b/src/vnet/sctp/sctp_debug.h
index b422d199640..b0059d5fe67 100644
--- a/src/vnet/sctp/sctp_debug.h
+++ b/src/vnet/sctp/sctp_debug.h
@@ -59,4 +59,11 @@ typedef enum _sctp_dbg
 #define SCTP_ADV_DBG_OUTPUT(_fmt, _args...)
 #endif
 
+#define SCTP_CONN_TRACKING_DEBUG (0)
+#if SCTP_CONN_TRACKING_DEBUG
+#define SCTP_CONN_TRACKING_DBG(_fmt, _args...) clib_warning (_fmt, ##_args)
+#else
+#define SCTP_CONN_TRACKING_DBG(_fmt, _args...)
+#endif
+
 #endif /* included_sctp_debug_h__ */
diff --git a/src/vnet/sctp/sctp_input.c b/src/vnet/sctp/sctp_input.c
index 4e5ea9194e8..a1bcb2b0ae3 100644
--- a/src/vnet/sctp/sctp_input.c
+++ b/src/vnet/sctp/sctp_input.c
@@ -122,17 +122,18 @@ phase_to_string (u8 phase)
   _ (PUNT_PHASE, "ip6-punt")
 
 static u8
-sctp_lookup_is_valid (transport_connection_t * t_conn,
+sctp_lookup_is_valid (transport_connection_t * trans_conn,
 		      sctp_header_t * sctp_hdr)
 {
-  sctp_connection_t *sctp_conn = sctp_get_connection_from_transport (t_conn);
+  sctp_connection_t *sctp_conn =
+    sctp_get_connection_from_transport (trans_conn);
 
   if (!sctp_conn)
     return 1;
 
-  u8 is_valid = (t_conn->lcl_port == sctp_hdr->dst_port
+  u8 is_valid = (trans_conn->lcl_port == sctp_hdr->dst_port
 		 && (sctp_conn->state == SCTP_STATE_CLOSED
-		     || t_conn->rmt_port == sctp_hdr->src_port));
+		     || trans_conn->rmt_port == sctp_hdr->src_port));
 
   return is_valid;
 }
@@ -146,7 +147,7 @@ sctp_lookup_connection (u32 fib_index, vlib_buffer_t * b, u8 thread_index,
 {
   sctp_main_t *tm = vnet_get_sctp_main ();
   sctp_header_t *sctp_hdr;
-  transport_connection_t *tconn;
+  transport_connection_t *trans_conn;
   sctp_connection_t *sctp_conn;
   u8 is_filtered, i;
   if (is_ip4)
@@ -154,14 +155,14 @@ sctp_lookup_connection (u32 fib_index, vlib_buffer_t * b, u8 thread_index,
       ip4_header_t *ip4_hdr;
       ip4_hdr = vlib_buffer_get_current (b);
       sctp_hdr = ip4_next_header (ip4_hdr);
-      tconn = session_lookup_connection_wt4 (fib_index,
-					     &ip4_hdr->dst_address,
-					     &ip4_hdr->src_address,
-					     sctp_hdr->dst_port,
-					     sctp_hdr->src_port,
-					     TRANSPORT_PROTO_SCTP,
-					     thread_index, &is_filtered);
-      if (tconn == 0)		/* Not primary connection */
+      trans_conn = session_lookup_connection_wt4 (fib_index,
+						  &ip4_hdr->dst_address,
+						  &ip4_hdr->src_address,
+						  sctp_hdr->dst_port,
+						  sctp_hdr->src_port,
+						  TRANSPORT_PROTO_SCTP,
+						  thread_index, &is_filtered);
+      if (trans_conn == 0)	/* Not primary connection */
 	{
 	  for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 	    {
@@ -172,28 +173,28 @@ sctp_lookup_connection (u32 fib_index, vlib_buffer_t * b, u8 thread_index,
 		      connection.rmt_ip.ip4.as_u32 ==
 		      ip4_hdr->src_address.as_u32))
 		{
-		  tconn =
+		  trans_conn =
 		    &tm->connections[thread_index]->sub_conn[i].connection;
 		  break;
 		}
 	    }
 	}
-      ASSERT (tconn != 0);
-      ASSERT (sctp_lookup_is_valid (tconn, sctp_hdr));
+      ASSERT (trans_conn != 0);
+      ASSERT (sctp_lookup_is_valid (trans_conn, sctp_hdr));
     }
   else
     {
       ip6_header_t *ip6_hdr;
       ip6_hdr = vlib_buffer_get_current (b);
       sctp_hdr = ip6_next_header (ip6_hdr);
-      tconn = session_lookup_connection_wt6 (fib_index,
-					     &ip6_hdr->dst_address,
-					     &ip6_hdr->src_address,
-					     sctp_hdr->dst_port,
-					     sctp_hdr->src_port,
-					     TRANSPORT_PROTO_SCTP,
-					     thread_index, &is_filtered);
-      if (tconn == 0)		/* Not primary connection */
+      trans_conn = session_lookup_connection_wt6 (fib_index,
+						  &ip6_hdr->dst_address,
+						  &ip6_hdr->src_address,
+						  sctp_hdr->dst_port,
+						  sctp_hdr->src_port,
+						  TRANSPORT_PROTO_SCTP,
+						  thread_index, &is_filtered);
+      if (trans_conn == 0)	/* Not primary connection */
 	{
 	  for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 	    {
@@ -210,16 +211,16 @@ sctp_lookup_connection (u32 fib_index, vlib_buffer_t * b, u8 thread_index,
 		      sub_conn[i].connection.rmt_ip.ip6.as_u64[1] ==
 		      ip6_hdr->src_address.as_u64[1]))
 		{
-		  tconn =
+		  trans_conn =
 		    &tm->connections[thread_index]->sub_conn[i].connection;
 		  break;
 		}
 	    }
 	}
-      ASSERT (tconn != 0);
-      ASSERT (sctp_lookup_is_valid (tconn, sctp_hdr));
+      ASSERT (trans_conn != 0);
+      ASSERT (sctp_lookup_is_valid (trans_conn, sctp_hdr));
     }
-  sctp_conn = sctp_get_connection_from_transport (tconn);
+  sctp_conn = sctp_get_connection_from_transport (trans_conn);
   return sctp_conn;
 }
 
@@ -321,6 +322,13 @@ sctp_handle_init (sctp_header_t * sctp_hdr,
   /* Save the INITIATE_TAG of the remote peer for this connection:
    * it MUST be used for the VERIFICATION_TAG parameter in the SCTP HEADER */
   sctp_conn->remote_tag = init_chunk->initiate_tag;
+  sctp_conn->remote_initial_tsn =
+    clib_net_to_host_u32 (init_chunk->initial_tsn);
+  sctp_conn->last_rcvd_tsn = sctp_conn->remote_initial_tsn;
+  sctp_conn->next_tsn_expected = sctp_conn->remote_initial_tsn + 1;
+  SCTP_CONN_TRACKING_DBG ("sctp_conn->remote_initial_tsn = %u",
+			  sctp_conn->remote_initial_tsn);
+
   sctp_conn->snd_opts.a_rwnd = clib_net_to_host_u32 (init_chunk->a_rwnd);
 
   /*
@@ -365,7 +373,8 @@ sctp_handle_init (sctp_header_t * sctp_hdr,
 	      {
 		sctp_cookie_preservative_param_t *cookie_pres =
 		  (sctp_cookie_preservative_param_t *) opt_params_hdr;
-		sctp_conn->life_span_inc = cookie_pres->life_span_inc;
+		sctp_conn->peer_cookie_life_span_increment =
+		  cookie_pres->life_span_inc;
 		break;
 	      }
 	    case SCTP_HOSTNAME_ADDRESS_TYPE:
@@ -443,6 +452,12 @@ sctp_handle_init_ack (sctp_header_t * sctp_hdr,
 
   /* remote_tag to be placed in the VERIFICATION_TAG field of the COOKIE_ECHO chunk */
   sctp_conn->remote_tag = init_ack_chunk->initiate_tag;
+  sctp_conn->remote_initial_tsn =
+    clib_net_to_host_u32 (init_ack_chunk->initial_tsn);
+  sctp_conn->last_rcvd_tsn = sctp_conn->remote_initial_tsn;
+  sctp_conn->next_tsn_expected = sctp_conn->remote_initial_tsn + 1;
+  SCTP_CONN_TRACKING_DBG ("sctp_conn->remote_initial_tsn = %u",
+			  sctp_conn->remote_initial_tsn);
   sctp_conn->snd_opts.a_rwnd = clib_net_to_host_u32 (init_ack_chunk->a_rwnd);
 
   u16 length = vnet_sctp_get_chunk_length (sctp_chunk_hdr);
@@ -527,48 +542,50 @@ sctp_handle_init_ack (sctp_header_t * sctp_hdr,
 
 /** Enqueue data for delivery to application */
 always_inline int
-sctp_session_enqueue_data (sctp_connection_t * tc, vlib_buffer_t * b,
+sctp_session_enqueue_data (sctp_connection_t * sctp_conn, vlib_buffer_t * b,
 			   u16 data_len, u8 conn_idx)
 {
   int written, error = SCTP_ERROR_ENQUEUED;
 
   written =
-    session_enqueue_stream_connection (&tc->sub_conn[conn_idx].connection, b,
-				       0, 1 /* queue event */ , 1);
+    session_enqueue_stream_connection (&sctp_conn->
+				       sub_conn[conn_idx].connection, b, 0,
+				       1 /* queue event */ ,
+				       1);
 
-  /* Update rcv_nxt */
+  /* Update next_tsn_expected */
   if (PREDICT_TRUE (written == data_len))
     {
-      tc->rcv_nxt += written;
+      sctp_conn->next_tsn_expected += written;
 
       SCTP_ADV_DBG ("CONN = %u, WRITTEN [%u] == DATA_LEN [%d]",
-		    tc->sub_conn[conn_idx].connection.c_index,
+		    sctp_conn->sub_conn[conn_idx].connection.c_index,
 		    written, data_len);
     }
   /* If more data written than expected, account for out-of-order bytes. */
   else if (written > data_len)
     {
-      tc->rcv_nxt += written;
+      sctp_conn->next_tsn_expected += written;
 
       SCTP_ADV_DBG ("CONN = %u, WRITTEN [%u] > DATA_LEN [%d]",
-		    tc->sub_conn[conn_idx].connection.c_index,
+		    sctp_conn->sub_conn[conn_idx].connection.c_index,
 		    written, data_len);
     }
   else if (written > 0)
     {
       /* We've written something but FIFO is probably full now */
-      tc->rcv_nxt += written;
+      sctp_conn->next_tsn_expected += written;
 
       error = SCTP_ERROR_PARTIALLY_ENQUEUED;
 
       SCTP_ADV_DBG
 	("CONN = %u, WRITTEN [%u] > 0 (SCTP_ERROR_PARTIALLY_ENQUEUED)",
-	 tc->sub_conn[conn_idx].connection.c_index, written);
+	 sctp_conn->sub_conn[conn_idx].connection.c_index, written);
     }
   else
     {
       SCTP_ADV_DBG ("CONN = %u, WRITTEN == 0 (SCTP_ERROR_FIFO_FULL)",
-		    tc->sub_conn[conn_idx].connection.c_index);
+		    sctp_conn->sub_conn[conn_idx].connection.c_index);
 
       return SCTP_ERROR_FIFO_FULL;
     }
@@ -576,6 +593,30 @@ sctp_session_enqueue_data (sctp_connection_t * tc, vlib_buffer_t * b,
   return error;
 }
 
+always_inline u8
+sctp_is_sack_delayable (sctp_connection_t * sctp_conn, u8 gapping)
+{
+  if (gapping != 0)
+    {
+      SCTP_CONN_TRACKING_DBG
+	("gapping != 0: CONN_INDEX = %u, sctp_conn->ack_state = %u",
+	 sctp_conn->sub_conn[idx].connection.c_index, sctp_conn->ack_state);
+      return 1;
+    }
+
+  if (sctp_conn->ack_state >= MAX_ENQUEABLE_SACKS)
+    {
+      SCTP_CONN_TRACKING_DBG
+	("sctp_conn->ack_state >= MAX_ENQUEABLE_SACKS: CONN_INDEX = %u, sctp_conn->ack_state = %u",
+	 sctp_conn->sub_conn[idx].connection.c_index, sctp_conn->ack_state);
+      return 1;
+    }
+
+  sctp_conn->ack_state += 1;
+
+  return 0;
+}
+
 always_inline u16
 sctp_handle_data (sctp_payload_data_chunk_t * sctp_data_chunk,
 		  sctp_connection_t * sctp_conn, vlib_buffer_t * b,
@@ -583,6 +624,7 @@ sctp_handle_data (sctp_payload_data_chunk_t * sctp_data_chunk,
 {
   u32 error = 0, n_data_bytes;
   u8 idx = sctp_pick_conn_idx_on_state (sctp_conn->state);
+  u8 gapping = 0;
 
   /* Check that the LOCALLY generated tag is being used by the REMOTE peer as the verification tag */
   if (sctp_conn->local_tag != sctp_data_chunk->sctp_hdr.verification_tag)
@@ -592,22 +634,36 @@ sctp_handle_data (sctp_payload_data_chunk_t * sctp_data_chunk,
 
   vnet_buffer (b)->sctp.sid = sctp_data_chunk->stream_id;
   vnet_buffer (b)->sctp.ssn = sctp_data_chunk->stream_seq;
-  vnet_buffer (b)->sctp.tsn = sctp_data_chunk->tsn;
+
+  u32 tsn = clib_net_to_host_u32 (sctp_data_chunk->tsn);
 
   vlib_buffer_advance (b, vnet_buffer (b)->sctp.data_offset);
   n_data_bytes = vnet_buffer (b)->sctp.data_len;
   ASSERT (n_data_bytes);
 
+  if (sctp_conn->next_tsn_expected != tsn)	// It means data transmission is GAPPING
+    {
+      SCTP_CONN_TRACKING_DBG
+	("GAPPING: CONN_INDEX = %u, sctp_conn->next_tsn_expected = %u, tsn = %u, diff = %u",
+	 sctp_conn->sub_conn[idx].connection.c_index,
+	 sctp_conn->next_tsn_expected, tsn,
+	 sctp_conn->next_tsn_expected - tsn);
+
+      gapping = 1;
+    }
+
+  sctp_conn->last_rcvd_tsn = tsn;
+
   SCTP_ADV_DBG ("POINTER_WITH_DATA = %p", b->data);
 
   /* In order data, enqueue. Fifo figures out by itself if any out-of-order
    * segments can be enqueued after fifo tail offset changes. */
   error = sctp_session_enqueue_data (sctp_conn, b, n_data_bytes, idx);
 
-  sctp_timer_update (sctp_conn, idx, SCTP_TIMER_T3_RXTX, SCTP_RTO_INIT);
-
   *next0 = sctp_next_output (sctp_conn->sub_conn[idx].c_is_ip4);
-  sctp_prepare_sack_chunk (sctp_conn, b);
+
+  if (sctp_is_sack_delayable (sctp_conn, gapping) != 0)
+    sctp_prepare_sack_chunk (sctp_conn, b);
 
   return error;
 }
@@ -741,23 +797,23 @@ sctp46_rcv_phase_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 
 	  sctp_full_hdr_t *full_hdr = (sctp_full_hdr_t *) sctp_hdr;
 
-	  transport_connection_t *t_conn =
+	  transport_connection_t *trans_conn =
 	    &sctp_conn->sub_conn[idx].connection;
 
-	  t_conn->lcl_port = sctp_hdr->dst_port;
-	  t_conn->rmt_port = sctp_hdr->src_port;
-	  t_conn->is_ip4 = is_ip4;
+	  trans_conn->lcl_port = sctp_hdr->dst_port;
+	  trans_conn->rmt_port = sctp_hdr->src_port;
+	  trans_conn->is_ip4 = is_ip4;
 
 	  if (is_ip4)
 	    {
-	      t_conn->lcl_ip.ip4.as_u32 = ip4_hdr->dst_address.as_u32;
-	      t_conn->rmt_ip.ip4.as_u32 = ip4_hdr->src_address.as_u32;
+	      trans_conn->lcl_ip.ip4.as_u32 = ip4_hdr->dst_address.as_u32;
+	      trans_conn->rmt_ip.ip4.as_u32 = ip4_hdr->src_address.as_u32;
 	    }
 	  else
 	    {
-	      clib_memcpy (&t_conn->lcl_ip.ip6, &ip6_hdr->dst_address,
+	      clib_memcpy (&trans_conn->lcl_ip.ip6, &ip6_hdr->dst_address,
 			   sizeof (ip6_address_t));
-	      clib_memcpy (&t_conn->rmt_ip.ip6, &ip6_hdr->src_address,
+	      clib_memcpy (&trans_conn->rmt_ip.ip6, &ip6_hdr->src_address,
 			   sizeof (ip6_address_t));
 	    }
 
@@ -800,7 +856,8 @@ sctp46_rcv_phase_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 					  new_sctp_conn, b0,
 					  sctp_implied_length);
 
-		  sctp_connection_init_vars (new_sctp_conn);
+		  sctp_init_mss (new_sctp_conn);
+		  //sctp_init_snd_vars (new_sctp_conn);
 
 		  if (session_stream_connect_notify
 		      (&new_sctp_conn->sub_conn[idx].connection, 0))
@@ -1244,12 +1301,18 @@ vlib_node_registration_t sctp6_established_phase_node;
 
 always_inline u16
 sctp_handle_sack (sctp_selective_ack_chunk_t * sack_chunk,
-		  sctp_connection_t * sctp_conn, vlib_buffer_t * b0,
+		  sctp_connection_t * sctp_conn, u8 idx, vlib_buffer_t * b0,
 		  u16 * next0)
 {
-  *next0 =
-    sctp_next_output (sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].
-		      connection.is_ip4);
+  /* Check that the LOCALLY generated tag is being used by the REMOTE peer as the verification tag */
+  if (sctp_conn->local_tag != sack_chunk->sctp_hdr.verification_tag)
+    {
+      return SCTP_ERROR_INVALID_TAG;
+    }
+
+  sctp_timer_update (sctp_conn, idx, SCTP_TIMER_T3_RXTX, SCTP_RTO_INIT);
+
+  *next0 = sctp_next_output (sctp_conn->sub_conn[idx].connection.is_ip4);
 
   return SCTP_ERROR_NONE;
 }
@@ -1404,12 +1467,13 @@ sctp46_listen_process_inline (vlib_main_t * vm,
 	    case INIT:
 	      sctp_connection_timers_init (child_conn);
 
+	      sctp_init_snd_vars (child_conn);
+
 	      error0 =
 		sctp_handle_init (sctp_hdr, sctp_chunk_hdr, child_conn, b0,
 				  sctp_implied_length);
 
-	      sctp_connection_init_vars (child_conn);
-
+	      sctp_init_mss (child_conn);
 
 	      if (error0 == SCTP_ERROR_NONE)
 		{
@@ -1536,25 +1600,25 @@ sctp46_established_phase_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 
 	  sctp_full_hdr_t *full_hdr = (sctp_full_hdr_t *) sctp_hdr;
 
-	  transport_connection_t *t_conn =
+	  transport_connection_t *trans_conn =
 	    &sctp_conn->sub_conn[idx].connection;
 
-	  t_conn->lcl_port = sctp_hdr->dst_port;
-	  t_conn->rmt_port = sctp_hdr->src_port;
-	  t_conn->is_ip4 = is_ip4;
+	  trans_conn->lcl_port = sctp_hdr->dst_port;
+	  trans_conn->rmt_port = sctp_hdr->src_port;
+	  trans_conn->is_ip4 = is_ip4;
 
 	  sctp_conn->sub_conn[idx].parent = sctp_conn;
 
 	  if (is_ip4)
 	    {
-	      t_conn->lcl_ip.ip4.as_u32 = ip4_hdr->dst_address.as_u32;
-	      t_conn->rmt_ip.ip4.as_u32 = ip4_hdr->src_address.as_u32;
+	      trans_conn->lcl_ip.ip4.as_u32 = ip4_hdr->dst_address.as_u32;
+	      trans_conn->rmt_ip.ip4.as_u32 = ip4_hdr->src_address.as_u32;
 	    }
 	  else
 	    {
-	      clib_memcpy (&t_conn->lcl_ip.ip6, &ip6_hdr->dst_address,
+	      clib_memcpy (&trans_conn->lcl_ip.ip6, &ip6_hdr->dst_address,
 			   sizeof (ip6_address_t));
-	      clib_memcpy (&t_conn->rmt_ip.ip6, &ip6_hdr->src_address,
+	      clib_memcpy (&trans_conn->rmt_ip.ip6, &ip6_hdr->src_address,
 			   sizeof (ip6_address_t));
 	    }
 
@@ -1582,7 +1646,7 @@ sctp46_established_phase_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	    case SACK:
 	      error0 =
 		sctp_handle_sack ((sctp_selective_ack_chunk_t *) sctp_hdr,
-				  sctp_conn, b0, &next0);
+				  sctp_conn, idx, b0, &next0);
 	      break;
 
 	    case HEARTBEAT:
@@ -1795,7 +1859,7 @@ sctp46_input_dispatcher (vlib_main_t * vm, vlib_node_runtime_t * node,
 	  sctp_header_t *sctp_hdr = 0;
 	  sctp_chunks_common_hdr_t *sctp_chunk_hdr = 0;
 	  sctp_connection_t *sctp_conn;
-	  transport_connection_t *tconn;
+	  transport_connection_t *trans_conn;
 	  ip4_header_t *ip4_hdr;
 	  ip6_header_t *ip6_hdr;
 	  u32 error0 = SCTP_ERROR_NO_LISTENER, next0 = SCTP_INPUT_NEXT_DROP;
@@ -1827,14 +1891,14 @@ sctp46_input_dispatcher (vlib_main_t * vm, vlib_node_runtime_t * node,
 	      n_data_bytes0 =
 		clib_net_to_host_u16 (ip4_hdr->length) - n_advance_bytes0;
 
-	      tconn = session_lookup_connection_wt4 (fib_index0,
-						     &ip4_hdr->dst_address,
-						     &ip4_hdr->src_address,
-						     sctp_hdr->dst_port,
-						     sctp_hdr->src_port,
-						     TRANSPORT_PROTO_SCTP,
-						     my_thread_index,
-						     &is_filtered);
+	      trans_conn = session_lookup_connection_wt4 (fib_index0,
+							  &ip4_hdr->dst_address,
+							  &ip4_hdr->src_address,
+							  sctp_hdr->dst_port,
+							  sctp_hdr->src_port,
+							  TRANSPORT_PROTO_SCTP,
+							  my_thread_index,
+							  &is_filtered);
 	    }
 	  else
 	    {
@@ -1850,14 +1914,14 @@ sctp46_input_dispatcher (vlib_main_t * vm, vlib_node_runtime_t * node,
 		n_advance_bytes0;
 	      n_advance_bytes0 += sizeof (ip6_hdr[0]);
 
-	      tconn = session_lookup_connection_wt6 (fib_index0,
-						     &ip6_hdr->dst_address,
-						     &ip6_hdr->src_address,
-						     sctp_hdr->dst_port,
-						     sctp_hdr->src_port,
-						     TRANSPORT_PROTO_SCTP,
-						     my_thread_index,
-						     &is_filtered);
+	      trans_conn = session_lookup_connection_wt6 (fib_index0,
+							  &ip6_hdr->dst_address,
+							  &ip6_hdr->src_address,
+							  sctp_hdr->dst_port,
+							  sctp_hdr->src_port,
+							  TRANSPORT_PROTO_SCTP,
+							  my_thread_index,
+							  &is_filtered);
 	    }
 
 	  /* Length check */
@@ -1867,7 +1931,7 @@ sctp46_input_dispatcher (vlib_main_t * vm, vlib_node_runtime_t * node,
 	      goto done;
 	    }
 
-	  sctp_conn = sctp_get_connection_from_transport (tconn);
+	  sctp_conn = sctp_get_connection_from_transport (trans_conn);
 	  vnet_sctp_common_hdr_params_net_to_host (sctp_chunk_hdr);
 
 	  u8 type = vnet_sctp_get_chunk_type (sctp_chunk_hdr);
@@ -1882,7 +1946,7 @@ sctp46_input_dispatcher (vlib_main_t * vm, vlib_node_runtime_t * node,
 	  if (PREDICT_TRUE (0 != sctp_conn))
 	    {
 	      /* Save connection index */
-	      vnet_buffer (b0)->sctp.connection_index = tconn->c_index;
+	      vnet_buffer (b0)->sctp.connection_index = trans_conn->c_index;
 	      vnet_buffer (b0)->sctp.data_offset = n_advance_bytes0;
 	      vnet_buffer (b0)->sctp.data_len = n_data_bytes0;
 
diff --git a/src/vnet/sctp/sctp_output.c b/src/vnet/sctp/sctp_output.c
index 841444e20a3..7b22cc59ac4 100644
--- a/src/vnet/sctp/sctp_output.c
+++ b/src/vnet/sctp/sctp_output.c
@@ -224,16 +224,17 @@ ip6_sctp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
 }
 
 void
-sctp_push_ip_hdr (sctp_main_t * tm, sctp_sub_connection_t * tc,
+sctp_push_ip_hdr (sctp_main_t * tm, sctp_sub_connection_t * sctp_sub_conn,
 		  vlib_buffer_t * b)
 {
   sctp_header_t *th = vlib_buffer_get_current (b);
   vlib_main_t *vm = vlib_get_main ();
-  if (tc->c_is_ip4)
+  if (sctp_sub_conn->c_is_ip4)
     {
       ip4_header_t *ih;
-      ih = vlib_buffer_push_ip4 (vm, b, &tc->c_lcl_ip4,
-				 &tc->c_rmt_ip4, IP_PROTOCOL_SCTP, 1);
+      ih = vlib_buffer_push_ip4 (vm, b, &sctp_sub_conn->c_lcl_ip4,
+				 &sctp_sub_conn->c_rmt_ip4, IP_PROTOCOL_SCTP,
+				 1);
       th->checksum = ip4_sctp_compute_checksum (vm, b, ih);
     }
   else
@@ -241,8 +242,8 @@ sctp_push_ip_hdr (sctp_main_t * tm, sctp_sub_connection_t * tc,
       ip6_header_t *ih;
       int bogus = ~0;
 
-      ih = vlib_buffer_push_ip6 (vm, b, &tc->c_lcl_ip6,
-				 &tc->c_rmt_ip6, IP_PROTOCOL_SCTP);
+      ih = vlib_buffer_push_ip6 (vm, b, &sctp_sub_conn->c_lcl_ip6,
+				 &sctp_sub_conn->c_rmt_ip6, IP_PROTOCOL_SCTP);
       th->checksum = ip6_sctp_compute_checksum (vm, b, ih, &bogus);
       ASSERT (!bogus);
     }
@@ -473,6 +474,11 @@ sctp_prepare_init_chunk (sctp_connection_t * sctp_conn, vlib_buffer_t * b)
   init_chunk->outbound_streams_count =
     clib_host_to_net_u16 (OUTBOUND_STREAMS_COUNT);
 
+  init_chunk->initial_tsn =
+    clib_host_to_net_u32 (sctp_conn->local_initial_tsn);
+  SCTP_CONN_TRACKING_DBG ("sctp_conn->local_initial_tsn = %u",
+			  sctp_conn->local_initial_tsn);
+
   sctp_conn->local_tag = init_chunk->initiate_tag;
 
   vnet_buffer (b)->sctp.connection_index = sub_conn->c_c_index;
@@ -495,7 +501,8 @@ sctp_compute_mac ()
 }
 
 void
-sctp_prepare_cookie_ack_chunk (sctp_connection_t * tc, vlib_buffer_t * b)
+sctp_prepare_cookie_ack_chunk (sctp_connection_t * sctp_conn,
+			       vlib_buffer_t * b)
 {
   vlib_main_t *vm = vlib_get_main ();
   u8 idx = sctp_pick_conn_idx_on_chunk (COOKIE_ACK);
@@ -515,18 +522,21 @@ sctp_prepare_cookie_ack_chunk (sctp_connection_t * tc, vlib_buffer_t * b)
     vlib_buffer_push_uninit (b, alloc_bytes);
 
   cookie_ack_chunk->sctp_hdr.checksum = 0;
-  cookie_ack_chunk->sctp_hdr.src_port = tc->sub_conn[idx].connection.lcl_port;
-  cookie_ack_chunk->sctp_hdr.dst_port = tc->sub_conn[idx].connection.rmt_port;
-  cookie_ack_chunk->sctp_hdr.verification_tag = tc->remote_tag;
+  cookie_ack_chunk->sctp_hdr.src_port =
+    sctp_conn->sub_conn[idx].connection.lcl_port;
+  cookie_ack_chunk->sctp_hdr.dst_port =
+    sctp_conn->sub_conn[idx].connection.rmt_port;
+  cookie_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
   vnet_sctp_set_chunk_type (&cookie_ack_chunk->chunk_hdr, COOKIE_ACK);
   vnet_sctp_set_chunk_length (&cookie_ack_chunk->chunk_hdr, chunk_len);
 
   vnet_buffer (b)->sctp.connection_index =
-    tc->sub_conn[idx].connection.c_index;
+    sctp_conn->sub_conn[idx].connection.c_index;
 }
 
 void
-sctp_prepare_cookie_echo_chunk (sctp_connection_t * tc, vlib_buffer_t * b,
+sctp_prepare_cookie_echo_chunk (sctp_connection_t * sctp_conn,
+				vlib_buffer_t * b,
 				sctp_state_cookie_param_t * sc)
 {
   vlib_main_t *vm = vlib_get_main ();
@@ -545,23 +555,23 @@ sctp_prepare_cookie_echo_chunk (sctp_connection_t * tc, vlib_buffer_t * b,
     vlib_buffer_push_uninit (b, alloc_bytes);
   cookie_echo_chunk->sctp_hdr.checksum = 0;
   cookie_echo_chunk->sctp_hdr.src_port =
-    tc->sub_conn[idx].connection.lcl_port;
+    sctp_conn->sub_conn[idx].connection.lcl_port;
   cookie_echo_chunk->sctp_hdr.dst_port =
-    tc->sub_conn[idx].connection.rmt_port;
-  cookie_echo_chunk->sctp_hdr.verification_tag = tc->remote_tag;
+    sctp_conn->sub_conn[idx].connection.rmt_port;
+  cookie_echo_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
   vnet_sctp_set_chunk_type (&cookie_echo_chunk->chunk_hdr, COOKIE_ECHO);
   vnet_sctp_set_chunk_length (&cookie_echo_chunk->chunk_hdr, chunk_len);
   clib_memcpy (&(cookie_echo_chunk->cookie), sc,
 	       sizeof (sctp_state_cookie_param_t));
   vnet_buffer (b)->sctp.connection_index =
-    tc->sub_conn[idx].connection.c_index;
+    sctp_conn->sub_conn[idx].connection.c_index;
 }
 
 /**
  * Convert buffer to INIT-ACK
  */
 void
-sctp_prepare_initack_chunk (sctp_connection_t * tc, vlib_buffer_t * b,
+sctp_prepare_initack_chunk (sctp_connection_t * sctp_conn, vlib_buffer_t * b,
 			    ip4_address_t * ip4_addr,
 			    ip6_address_t * ip6_addr)
 {
@@ -588,7 +598,7 @@ sctp_prepare_initack_chunk (sctp_connection_t * tc, vlib_buffer_t * b,
       alloc_bytes += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
     }
 
-  if (tc->sub_conn[idx].connection.is_ip4)
+  if (sctp_conn->sub_conn[idx].connection.is_ip4)
     alloc_bytes += sizeof (sctp_ipv4_addr_param_t);
   else
     alloc_bytes += sizeof (sctp_ipv6_addr_param_t);
@@ -649,11 +659,11 @@ sctp_prepare_initack_chunk (sctp_connection_t * tc, vlib_buffer_t * b,
       pointer_offset += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
     }
 
-  if (tc->sub_conn[idx].connection.is_ip4)
+  if (sctp_conn->sub_conn[idx].connection.is_ip4)
     {
       ip4_param = (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
       ip4_param->address.as_u32 =
-	tc->sub_conn[idx].connection.lcl_ip.ip4.as_u32;
+	sctp_conn->sub_conn[idx].connection.lcl_ip.ip4.as_u32;
 
       pointer_offset += sizeof (sctp_ipv4_addr_param_t);
     }
@@ -661,44 +671,49 @@ sctp_prepare_initack_chunk (sctp_connection_t * tc, vlib_buffer_t * b,
     {
       ip6_param = (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
       ip6_param->address.as_u64[0] =
-	tc->sub_conn[idx].connection.lcl_ip.ip6.as_u64[0];
+	sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[0];
       ip6_param->address.as_u64[1] =
-	tc->sub_conn[idx].connection.lcl_ip.ip6.as_u64[1];
+	sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[1];
 
       pointer_offset += sizeof (sctp_ipv6_addr_param_t);
     }
 
   /* src_port & dst_port are already in network byte-order */
   init_ack_chunk->sctp_hdr.checksum = 0;
-  init_ack_chunk->sctp_hdr.src_port = tc->sub_conn[idx].connection.lcl_port;
-  init_ack_chunk->sctp_hdr.dst_port = tc->sub_conn[idx].connection.rmt_port;
-  /* the tc->verification_tag is already in network byte-order (being a copy of the init_tag coming with the INIT chunk) */
-  init_ack_chunk->sctp_hdr.verification_tag = tc->remote_tag;
+  init_ack_chunk->sctp_hdr.src_port =
+    sctp_conn->sub_conn[idx].connection.lcl_port;
+  init_ack_chunk->sctp_hdr.dst_port =
+    sctp_conn->sub_conn[idx].connection.rmt_port;
+  /* the sctp_conn->verification_tag is already in network byte-order (being a copy of the init_tag coming with the INIT chunk) */
+  init_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
+  init_ack_chunk->initial_tsn =
+    clib_host_to_net_u32 (sctp_conn->local_initial_tsn);
+  SCTP_CONN_TRACKING_DBG ("init_ack_chunk->initial_tsn = %u",
+			  init_ack_chunk->initial_tsn);
 
   vnet_sctp_set_chunk_type (&init_ack_chunk->chunk_hdr, INIT_ACK);
   vnet_sctp_set_chunk_length (&init_ack_chunk->chunk_hdr, chunk_len);
 
   init_ack_chunk->initiate_tag =
     clib_host_to_net_u32 (random_u32 (&random_seed));
-  /* As per RFC 4960, the initial_tsn may be the same value as the initiate_tag */
-  init_ack_chunk->initial_tsn = init_ack_chunk->initiate_tag;
+
   init_ack_chunk->a_rwnd = clib_host_to_net_u32 (DEFAULT_A_RWND);
   init_ack_chunk->inboud_streams_count =
     clib_host_to_net_u16 (INBOUND_STREAMS_COUNT);
   init_ack_chunk->outbound_streams_count =
     clib_host_to_net_u16 (OUTBOUND_STREAMS_COUNT);
 
-  tc->local_tag = init_ack_chunk->initiate_tag;
+  sctp_conn->local_tag = init_ack_chunk->initiate_tag;
 
   vnet_buffer (b)->sctp.connection_index =
-    tc->sub_conn[idx].connection.c_index;
+    sctp_conn->sub_conn[idx].connection.c_index;
 }
 
 /**
  * Convert buffer to SHUTDOWN
  */
 void
-sctp_prepare_shutdown_chunk (sctp_connection_t * tc, vlib_buffer_t * b)
+sctp_prepare_shutdown_chunk (sctp_connection_t * sctp_conn, vlib_buffer_t * b)
 {
   vlib_main_t *vm = vlib_get_main ();
   u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN);
@@ -718,30 +733,32 @@ sctp_prepare_shutdown_chunk (sctp_connection_t * tc, vlib_buffer_t * b)
 
   shutdown_chunk->sctp_hdr.checksum = 0;
   /* No need of host_to_net conversion, already in net-byte order */
-  shutdown_chunk->sctp_hdr.src_port = tc->sub_conn[idx].connection.lcl_port;
-  shutdown_chunk->sctp_hdr.dst_port = tc->sub_conn[idx].connection.rmt_port;
-  shutdown_chunk->sctp_hdr.verification_tag = tc->remote_tag;
+  shutdown_chunk->sctp_hdr.src_port =
+    sctp_conn->sub_conn[idx].connection.lcl_port;
+  shutdown_chunk->sctp_hdr.dst_port =
+    sctp_conn->sub_conn[idx].connection.rmt_port;
+  shutdown_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
   vnet_sctp_set_chunk_type (&shutdown_chunk->chunk_hdr, SHUTDOWN);
   vnet_sctp_set_chunk_length (&shutdown_chunk->chunk_hdr, chunk_len);
 
-  shutdown_chunk->cumulative_tsn_ack = tc->rcv_las;
+  shutdown_chunk->cumulative_tsn_ack = sctp_conn->last_rcvd_tsn;
 
   vnet_buffer (b)->sctp.connection_index =
-    tc->sub_conn[idx].connection.c_index;
+    sctp_conn->sub_conn[idx].connection.c_index;
 }
 
 /*
  * Send SHUTDOWN
  */
 void
-sctp_send_shutdown (sctp_connection_t * tc)
+sctp_send_shutdown (sctp_connection_t * sctp_conn)
 {
   vlib_buffer_t *b;
   u32 bi;
   sctp_main_t *tm = vnet_get_sctp_main ();
   vlib_main_t *vm = vlib_get_main ();
 
-  if (sctp_check_outstanding_data_chunks (tc) > 0)
+  if (sctp_check_outstanding_data_chunks (sctp_conn) > 0)
     return;
 
   if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
@@ -749,18 +766,20 @@ sctp_send_shutdown (sctp_connection_t * tc)
 
   b = vlib_get_buffer (vm, bi);
   sctp_init_buffer (vm, b);
-  sctp_prepare_shutdown_chunk (tc, b);
+  sctp_prepare_shutdown_chunk (sctp_conn, b);
 
   u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN);
-  sctp_push_ip_hdr (tm, &tc->sub_conn[idx], b);
-  sctp_enqueue_to_output_now (vm, b, bi, tc->sub_conn[idx].connection.is_ip4);
+  sctp_push_ip_hdr (tm, &sctp_conn->sub_conn[idx], b);
+  sctp_enqueue_to_output_now (vm, b, bi,
+			      sctp_conn->sub_conn[idx].connection.is_ip4);
 }
 
 /**
  * Convert buffer to SHUTDOWN_ACK
  */
 void
-sctp_prepare_shutdown_ack_chunk (sctp_connection_t * tc, vlib_buffer_t * b)
+sctp_prepare_shutdown_ack_chunk (sctp_connection_t * sctp_conn,
+				 vlib_buffer_t * b)
 {
   u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN_ACK);
   u16 alloc_bytes = sizeof (sctp_shutdown_association_chunk_t);
@@ -774,30 +793,30 @@ sctp_prepare_shutdown_ack_chunk (sctp_connection_t * tc, vlib_buffer_t * b)
   shutdown_ack_chunk->sctp_hdr.checksum = 0;
   /* No need of host_to_net conversion, already in net-byte order */
   shutdown_ack_chunk->sctp_hdr.src_port =
-    tc->sub_conn[idx].connection.lcl_port;
+    sctp_conn->sub_conn[idx].connection.lcl_port;
   shutdown_ack_chunk->sctp_hdr.dst_port =
-    tc->sub_conn[idx].connection.rmt_port;
-  shutdown_ack_chunk->sctp_hdr.verification_tag = tc->remote_tag;
+    sctp_conn->sub_conn[idx].connection.rmt_port;
+  shutdown_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
 
   vnet_sctp_set_chunk_type (&shutdown_ack_chunk->chunk_hdr, SHUTDOWN_ACK);
   vnet_sctp_set_chunk_length (&shutdown_ack_chunk->chunk_hdr, chunk_len);
 
   vnet_buffer (b)->sctp.connection_index =
-    tc->sub_conn[idx].connection.c_index;
+    sctp_conn->sub_conn[idx].connection.c_index;
 }
 
 /*
  * Send SHUTDOWN_ACK
  */
 void
-sctp_send_shutdown_ack (sctp_connection_t * tc)
+sctp_send_shutdown_ack (sctp_connection_t * sctp_conn)
 {
   vlib_buffer_t *b;
   u32 bi;
   sctp_main_t *tm = vnet_get_sctp_main ();
   vlib_main_t *vm = vlib_get_main ();
 
-  if (sctp_check_outstanding_data_chunks (tc) > 0)
+  if (sctp_check_outstanding_data_chunks (sctp_conn) > 0)
     return;
 
   if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
@@ -805,22 +824,23 @@ sctp_send_shutdown_ack (sctp_connection_t * tc)
 
   b = vlib_get_buffer (vm, bi);
   sctp_init_buffer (vm, b);
-  sctp_prepare_shutdown_ack_chunk (tc, b);
+  sctp_prepare_shutdown_ack_chunk (sctp_conn, b);
 
   u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN_ACK);
-  sctp_push_ip_hdr (tm, &tc->sub_conn[idx], b);
-  sctp_enqueue_to_ip_lookup (vm, b, bi, tc->sub_conn[idx].connection.is_ip4);
+  sctp_push_ip_hdr (tm, &sctp_conn->sub_conn[idx], b);
+  sctp_enqueue_to_ip_lookup (vm, b, bi,
+			     sctp_conn->sub_conn[idx].connection.is_ip4);
 
   /* Start the SCTP_TIMER_T2_SHUTDOWN timer */
-  sctp_timer_set (tc, idx, SCTP_TIMER_T2_SHUTDOWN, SCTP_RTO_INIT);
-  tc->state = SCTP_STATE_SHUTDOWN_ACK_SENT;
+  sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN, SCTP_RTO_INIT);
+  sctp_conn->state = SCTP_STATE_SHUTDOWN_ACK_SENT;
 }
 
 /**
  * Convert buffer to SACK
  */
 void
-sctp_prepare_sack_chunk (sctp_connection_t * tc, vlib_buffer_t * b)
+sctp_prepare_sack_chunk (sctp_connection_t * sctp_conn, vlib_buffer_t * b)
 {
   vlib_main_t *vm = vlib_get_main ();
   u8 idx = sctp_pick_conn_idx_on_chunk (SACK);
@@ -839,21 +859,84 @@ sctp_prepare_sack_chunk (sctp_connection_t * tc, vlib_buffer_t * b)
   sctp_selective_ack_chunk_t *sack = vlib_buffer_push_uninit (b, alloc_bytes);
 
   sack->sctp_hdr.checksum = 0;
-  sack->sctp_hdr.src_port = tc->sub_conn[idx].connection.lcl_port;
-  sack->sctp_hdr.dst_port = tc->sub_conn[idx].connection.rmt_port;
-  sack->sctp_hdr.verification_tag = tc->remote_tag;
+  sack->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
+  sack->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
+  sack->sctp_hdr.verification_tag = sctp_conn->remote_tag;
   vnet_sctp_set_chunk_type (&sack->chunk_hdr, SACK);
   vnet_sctp_set_chunk_length (&sack->chunk_hdr, chunk_len);
 
+  sack->cumulative_tsn_ack = sctp_conn->next_tsn_expected;
+
+  sctp_conn->ack_state = 0;
+
+  vnet_buffer (b)->sctp.connection_index =
+    sctp_conn->sub_conn[idx].connection.c_index;
+}
+
+/**
+ * Convert buffer to HEARTBEAT
+ */
+void
+sctp_prepare_heartbeat_chunk (sctp_connection_t * sctp_conn,
+			      vlib_buffer_t * b)
+{
+  vlib_main_t *vm = vlib_get_main ();
+  u8 idx = sctp_pick_conn_idx_on_chunk (HEARTBEAT);
+  u16 alloc_bytes = sizeof (sctp_hb_req_chunk_t);
+
+  b = sctp_reuse_buffer (vm, b);
+
+  /* As per RFC 4960 the chunk_length value does NOT contemplate
+   * the size of the first header (see sctp_header_t) and any padding
+   */
+  u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
+
+  alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
+
+  sctp_hb_req_chunk_t *hb_req = vlib_buffer_push_uninit (b, alloc_bytes);
+
+  hb_req->sctp_hdr.checksum = 0;
+  /* No need of host_to_net conversion, already in net-byte order */
+  hb_req->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
+  hb_req->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
+  hb_req->sctp_hdr.verification_tag = sctp_conn->remote_tag;
+  hb_req->hb_info.param_hdr.type = clib_host_to_net_u16 (1);
+  hb_req->hb_info.param_hdr.length =
+    clib_host_to_net_u16 (sizeof (hb_req->hb_info.hb_info));
+
+  vnet_sctp_set_chunk_type (&hb_req->chunk_hdr, HEARTBEAT);
+  vnet_sctp_set_chunk_length (&hb_req->chunk_hdr, chunk_len);
+
   vnet_buffer (b)->sctp.connection_index =
-    tc->sub_conn[idx].connection.c_index;
+    sctp_conn->sub_conn[idx].connection.c_index;
+}
+
+void
+sctp_send_heartbeat (sctp_connection_t * sctp_conn)
+{
+  vlib_buffer_t *b;
+  u32 bi;
+  sctp_main_t *tm = vnet_get_sctp_main ();
+  vlib_main_t *vm = vlib_get_main ();
+
+  if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
+    return;
+
+  b = vlib_get_buffer (vm, bi);
+  sctp_init_buffer (vm, b);
+  sctp_prepare_heartbeat_chunk (sctp_conn, b);
+
+  u8 idx = sctp_pick_conn_idx_on_state (SCTP_STATE_ESTABLISHED);
+  sctp_push_ip_hdr (tm, &sctp_conn->sub_conn[idx], b);
+  sctp_enqueue_to_ip_lookup (vm, b, bi,
+			     sctp_conn->sub_conn[idx].connection.is_ip4);
 }
 
 /**
  * Convert buffer to SHUTDOWN_COMPLETE
  */
 void
-sctp_prepare_shutdown_complete_chunk (sctp_connection_t * tc,
+sctp_prepare_shutdown_complete_chunk (sctp_connection_t * sctp_conn,
 				      vlib_buffer_t * b)
 {
   u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN_COMPLETE);
@@ -868,20 +951,20 @@ sctp_prepare_shutdown_complete_chunk (sctp_connection_t * tc,
   shutdown_complete->sctp_hdr.checksum = 0;
   /* No need of host_to_net conversion, already in net-byte order */
   shutdown_complete->sctp_hdr.src_port =
-    tc->sub_conn[idx].connection.lcl_port;
+    sctp_conn->sub_conn[idx].connection.lcl_port;
   shutdown_complete->sctp_hdr.dst_port =
-    tc->sub_conn[idx].connection.rmt_port;
-  shutdown_complete->sctp_hdr.verification_tag = tc->remote_tag;
+    sctp_conn->sub_conn[idx].connection.rmt_port;
+  shutdown_complete->sctp_hdr.verification_tag = sctp_conn->remote_tag;
 
   vnet_sctp_set_chunk_type (&shutdown_complete->chunk_hdr, SHUTDOWN_COMPLETE);
   vnet_sctp_set_chunk_length (&shutdown_complete->chunk_hdr, chunk_len);
 
   vnet_buffer (b)->sctp.connection_index =
-    tc->sub_conn[idx].connection.c_index;
+    sctp_conn->sub_conn[idx].connection.c_index;
 }
 
 void
-sctp_send_shutdown_complete (sctp_connection_t * tc)
+sctp_send_shutdown_complete (sctp_connection_t * sctp_conn)
 {
   vlib_buffer_t *b;
   u32 bi;
@@ -893,13 +976,14 @@ sctp_send_shutdown_complete (sctp_connection_t * tc)
 
   b = vlib_get_buffer (vm, bi);
   sctp_init_buffer (vm, b);
-  sctp_prepare_shutdown_complete_chunk (tc, b);
+  sctp_prepare_shutdown_complete_chunk (sctp_conn, b);
 
   u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN_COMPLETE);
-  sctp_push_ip_hdr (tm, &tc->sub_conn[idx], b);
-  sctp_enqueue_to_ip_lookup (vm, b, bi, tc->sub_conn[idx].connection.is_ip4);
+  sctp_push_ip_hdr (tm, &sctp_conn->sub_conn[idx], b);
+  sctp_enqueue_to_ip_lookup (vm, b, bi,
+			     sctp_conn->sub_conn[idx].connection.is_ip4);
 
-  tc->state = SCTP_STATE_CLOSED;
+  sctp_conn->state = SCTP_STATE_CLOSED;
 }
 
 
@@ -907,7 +991,7 @@ sctp_send_shutdown_complete (sctp_connection_t * tc)
  *  Send INIT
  */
 void
-sctp_send_init (sctp_connection_t * tc)
+sctp_send_init (sctp_connection_t * sctp_conn)
 {
   vlib_buffer_t *b;
   u32 bi;
@@ -921,20 +1005,20 @@ sctp_send_init (sctp_connection_t * tc)
   u8 idx = sctp_pick_conn_idx_on_chunk (INIT);
 
   sctp_init_buffer (vm, b);
-  sctp_prepare_init_chunk (tc, b);
+  sctp_prepare_init_chunk (sctp_conn, b);
 
   /* Measure RTT with this */
-  tc->rtt_ts = sctp_time_now ();
-  tc->rtt_seq = tc->snd_nxt;
-  tc->rto_boff = 0;
+  sctp_conn->rtt_ts = sctp_time_now ();
+  sctp_conn->rtt_seq = sctp_conn->next_tsn;
 
-  sctp_push_ip_hdr (tm, &tc->sub_conn[idx], b);
-  sctp_enqueue_to_ip_lookup_now (vm, b, bi, tc->sub_conn[idx].c_is_ip4);
+  sctp_push_ip_hdr (tm, &sctp_conn->sub_conn[idx], b);
+  sctp_enqueue_to_ip_lookup_now (vm, b, bi,
+				 sctp_conn->sub_conn[idx].c_is_ip4);
 
   /* Start the T1_INIT timer */
-  sctp_timer_set (tc, idx, SCTP_TIMER_T1_INIT, SCTP_RTO_INIT);
+  sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T1_INIT, SCTP_RTO_INIT);
   /* Change state to COOKIE_WAIT */
-  tc->state = SCTP_STATE_COOKIE_WAIT;
+  sctp_conn->state = SCTP_STATE_COOKIE_WAIT;
 }
 
 always_inline u8
@@ -947,7 +1031,7 @@ sctp_in_cong_recovery (sctp_connection_t * sctp_conn)
  * Push SCTP header and update connection variables
  */
 static void
-sctp_push_hdr_i (sctp_connection_t * tc, vlib_buffer_t * b,
+sctp_push_hdr_i (sctp_connection_t * sctp_conn, vlib_buffer_t * b,
 		 sctp_state_t next_state)
 {
   u8 idx = sctp_pick_conn_idx_on_chunk (DATA);
@@ -971,11 +1055,13 @@ sctp_push_hdr_i (sctp_connection_t * tc, vlib_buffer_t * b,
     vlib_buffer_push_uninit (b, bytes_to_add);
 
   data_chunk->sctp_hdr.checksum = 0;
-  data_chunk->sctp_hdr.src_port = tc->sub_conn[idx].connection.lcl_port;
-  data_chunk->sctp_hdr.dst_port = tc->sub_conn[idx].connection.rmt_port;
-  data_chunk->sctp_hdr.verification_tag = tc->remote_tag;
+  data_chunk->sctp_hdr.src_port =
+    sctp_conn->sub_conn[idx].connection.lcl_port;
+  data_chunk->sctp_hdr.dst_port =
+    sctp_conn->sub_conn[idx].connection.rmt_port;
+  data_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
 
-  data_chunk->tsn = clib_host_to_net_u32 (0);
+  data_chunk->tsn = clib_host_to_net_u32 (sctp_conn->next_tsn);
   data_chunk->stream_id = clib_host_to_net_u16 (0);
   data_chunk->stream_seq = clib_host_to_net_u16 (0);
 
@@ -985,20 +1071,23 @@ sctp_push_hdr_i (sctp_connection_t * tc, vlib_buffer_t * b,
   SCTP_ADV_DBG_OUTPUT ("POINTER_WITH_DATA = %p, DATA_OFFSET = %u",
 		       b->data, b->current_data);
 
+  sctp_conn->next_tsn += data_len;
+
   vnet_buffer (b)->sctp.connection_index =
-    tc->sub_conn[idx].connection.c_index;
+    sctp_conn->sub_conn[idx].connection.c_index;
 }
 
 u32
-sctp_push_header (transport_connection_t * tconn, vlib_buffer_t * b)
+sctp_push_header (transport_connection_t * trans_conn, vlib_buffer_t * b)
 {
-  sctp_connection_t *tc = sctp_get_connection_from_transport (tconn);
-  sctp_push_hdr_i (tc, b, SCTP_STATE_ESTABLISHED);
+  sctp_connection_t *sctp_conn =
+    sctp_get_connection_from_transport (trans_conn);
+  sctp_push_hdr_i (sctp_conn, b, SCTP_STATE_ESTABLISHED);
 
-  if (tc->rtt_ts == 0 && !sctp_in_cong_recovery (tc))
+  if (sctp_conn->rtt_ts == 0 && !sctp_in_cong_recovery (sctp_conn))
     {
-      tc->rtt_ts = sctp_time_now ();
-      tc->rtt_seq = tc->snd_nxt;
+      sctp_conn->rtt_ts = sctp_time_now ();
+      sctp_conn->rtt_seq = sctp_conn->next_tsn;
     }
   sctp_trajectory_add_start (b0, 3);
 
@@ -1030,7 +1119,7 @@ sctp46_output_inline (vlib_main_t * vm,
 	  u32 bi0;
 	  vlib_buffer_t *b0;
 	  sctp_header_t *sctp_hdr = 0;
-	  sctp_connection_t *tc0;
+	  sctp_connection_t *sctp_conn;
 	  sctp_tx_trace_t *t0;
 	  sctp_header_t *th0 = 0;
 	  u32 error0 = SCTP_ERROR_PKTS_SENT, next0 =
@@ -1048,80 +1137,82 @@ sctp46_output_inline (vlib_main_t * vm,
 	  n_left_to_next -= 1;
 
 	  b0 = vlib_get_buffer (vm, bi0);
-	  tc0 = sctp_connection_get (vnet_buffer (b0)->sctp.connection_index,
-				     my_thread_index);
+	  sctp_conn =
+	    sctp_connection_get (vnet_buffer (b0)->sctp.connection_index,
+				 my_thread_index);
 
-	  if (PREDICT_FALSE (tc0 == 0))
+	  if (PREDICT_FALSE (sctp_conn == 0))
 	    {
 	      error0 = SCTP_ERROR_INVALID_CONNECTION;
 	      next0 = SCTP_OUTPUT_NEXT_DROP;
 	      goto done;
 	    }
 
-	  u8 idx = sctp_pick_conn_idx_on_state (tc0->state);
+	  u8 idx = sctp_pick_conn_idx_on_state (sctp_conn->state);
 
 	  th0 = vlib_buffer_get_current (b0);
 
 	  if (is_ip4)
 	    {
-	      ip4_header_t *th0 = vlib_buffer_push_ip4 (vm,
-							b0,
-							&tc0->sub_conn
-							[idx].connection.
-							lcl_ip.ip4,
-							&tc0->
-							sub_conn
-							[idx].connection.
-							rmt_ip.ip4,
-							IP_PROTOCOL_SCTP, 1);
-
-	      u32 checksum = ip4_sctp_compute_checksum (vm, b0, th0);
-
-	      sctp_hdr = ip4_next_header (th0);
+	      ip4_header_t *iph4 = vlib_buffer_push_ip4 (vm,
+							 b0,
+							 &sctp_conn->sub_conn
+							 [idx].connection.
+							 lcl_ip.ip4,
+							 &sctp_conn->
+							 sub_conn
+							 [idx].connection.
+							 rmt_ip.ip4,
+							 IP_PROTOCOL_SCTP, 1);
+
+	      u32 checksum = ip4_sctp_compute_checksum (vm, b0, iph4);
+
+	      sctp_hdr = ip4_next_header (iph4);
 	      sctp_hdr->checksum = checksum;
 
 	      vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
-	      th0->checksum = 0;
 
 #if SCTP_DEBUG_STATE_MACHINE
-	      packet_length = clib_net_to_host_u16 (th0->length);
+	      packet_length = clib_net_to_host_u16 (iph4->length);
 #endif
 	    }
 	  else
 	    {
-	      ip6_header_t *ih0;
-	      ih0 = vlib_buffer_push_ip6 (vm,
-					  b0,
-					  &tc0->sub_conn[idx].
-					  connection.lcl_ip.ip6,
-					  &tc0->sub_conn[idx].
-					  connection.rmt_ip.ip6,
-					  IP_PROTOCOL_SCTP);
+	      ip6_header_t *iph6 = vlib_buffer_push_ip6 (vm,
+							 b0,
+							 &sctp_conn->sub_conn
+							 [idx].
+							 connection.lcl_ip.
+							 ip6,
+							 &sctp_conn->sub_conn
+							 [idx].
+							 connection.rmt_ip.
+							 ip6,
+							 IP_PROTOCOL_SCTP);
 
 	      int bogus = ~0;
-	      u32 checksum = ip6_sctp_compute_checksum (vm, b0, ih0, &bogus);
+	      u32 checksum = ip6_sctp_compute_checksum (vm, b0, iph6, &bogus);
 	      ASSERT (!bogus);
 
-	      sctp_hdr = ip6_next_header (ih0);
+	      sctp_hdr = ip6_next_header (iph6);
 	      sctp_hdr->checksum = checksum;
 
-	      vnet_buffer (b0)->l3_hdr_offset = (u8 *) ih0 - b0->data;
+	      vnet_buffer (b0)->l3_hdr_offset = (u8 *) iph6 - b0->data;
 	      vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
-	      th0->checksum = 0;
 
 #if SCTP_DEBUG_STATE_MACHINE
-	      packet_length = clib_net_to_host_u16 (ih0->payload_length);
+	      packet_length = clib_net_to_host_u16 (iph6->payload_length);
 #endif
 	    }
 
 	  u8 is_valid =
-	    (tc0->sub_conn[idx].connection.lcl_port ==
+	    (sctp_conn->sub_conn[idx].connection.lcl_port ==
 	     sctp_hdr->src_port
-	     || tc0->sub_conn[idx].connection.lcl_port ==
+	     || sctp_conn->sub_conn[idx].connection.lcl_port ==
 	     sctp_hdr->dst_port)
-	    && (tc0->sub_conn[idx].connection.rmt_port ==
+	    && (sctp_conn->sub_conn[idx].connection.rmt_port ==
 		sctp_hdr->dst_port
-		|| tc0->sub_conn[idx].connection.rmt_port ==
+		|| sctp_conn->sub_conn[idx].connection.rmt_port ==
 		sctp_hdr->src_port);
 
 	  sctp_full_hdr_t *full_hdr = (sctp_full_hdr_t *) sctp_hdr;
@@ -1134,13 +1225,14 @@ sctp46_output_inline (vlib_main_t * vm,
 				      "chunk_type = %u [%s], "
 				      "connection.lcl_port = %u, sctp_hdr->src_port = %u, "
 				      "connection.rmt_port = %u, sctp_hdr->dst_port = %u",
-				      tc0->sub_conn
+				      sctp_conn->sub_conn
 				      [idx].connection.c_index, packet_length,
 				      chunk_type,
 				      sctp_chunk_to_string (chunk_type),
-				      tc0->sub_conn[idx].connection.lcl_port,
-				      sctp_hdr->src_port,
-				      tc0->sub_conn[idx].connection.rmt_port,
+				      sctp_conn->sub_conn[idx].
+				      connection.lcl_port, sctp_hdr->src_port,
+				      sctp_conn->sub_conn[idx].
+				      connection.rmt_port,
 				      sctp_hdr->dst_port);
 
 	      error0 = SCTP_ERROR_UNKOWN_CHUNK;
@@ -1151,8 +1243,8 @@ sctp46_output_inline (vlib_main_t * vm,
 	  SCTP_DBG_STATE_MACHINE
 	    ("CONN_INDEX = %u, CURR_CONN_STATE = %u (%s), "
 	     "CHUNK_TYPE = %s, " "SRC_PORT = %u, DST_PORT = %u",
-	     tc0->sub_conn[idx].connection.c_index,
-	     tc0->state, sctp_state_to_string (tc0->state),
+	     sctp_conn->sub_conn[idx].connection.c_index,
+	     sctp_conn->state, sctp_state_to_string (sctp_conn->state),
 	     sctp_chunk_to_string (chunk_type), full_hdr->hdr.src_port,
 	     full_hdr->hdr.dst_port);
 
@@ -1160,7 +1252,7 @@ sctp46_output_inline (vlib_main_t * vm,
 	    SCTP_ADV_DBG_OUTPUT ("PACKET_LENGTH = %u", packet_length);
 
 	  /* Let's make sure the state-machine does not send anything crazy */
-	  switch (tc0->state)
+	  switch (sctp_conn->state)
 	    {
 	    case SCTP_STATE_CLOSED:
 	      {
@@ -1169,7 +1261,7 @@ sctp46_output_inline (vlib_main_t * vm,
 		    SCTP_DBG_STATE_MACHINE
 		      ("Sending the wrong chunk (%s) based on state-machine status (%s)",
 		       sctp_chunk_to_string (chunk_type),
-		       sctp_state_to_string (tc0->state));
+		       sctp_state_to_string (sctp_conn->state));
 
 		    error0 = SCTP_ERROR_UNKOWN_CHUNK;
 		    next0 = SCTP_OUTPUT_NEXT_DROP;
@@ -1185,7 +1277,7 @@ sctp46_output_inline (vlib_main_t * vm,
 		  SCTP_DBG_STATE_MACHINE
 		    ("Sending the wrong chunk (%s) based on state-machine status (%s)",
 		     sctp_chunk_to_string (chunk_type),
-		     sctp_state_to_string (tc0->state));
+		     sctp_state_to_string (sctp_conn->state));
 
 		  error0 = SCTP_ERROR_UNKOWN_CHUNK;
 		  next0 = SCTP_OUTPUT_NEXT_DROP;
@@ -1198,29 +1290,35 @@ sctp46_output_inline (vlib_main_t * vm,
 		  SCTP_DBG_STATE_MACHINE
 		    ("Sending the wrong chunk (%s) based on state-machine status (%s)",
 		     sctp_chunk_to_string (chunk_type),
-		     sctp_state_to_string (tc0->state));
+		     sctp_state_to_string (sctp_conn->state));
 
 		  error0 = SCTP_ERROR_UNKOWN_CHUNK;
 		  next0 = SCTP_OUTPUT_NEXT_DROP;
 		  goto done;
 		}
 	      /* Change state */
-	      tc0->state = SCTP_STATE_COOKIE_ECHOED;
+	      sctp_conn->state = SCTP_STATE_COOKIE_ECHOED;
 	      break;
 	    default:
 	      SCTP_DBG_STATE_MACHINE
 		("Sending chunk (%s) based on state-machine status (%s)",
 		 sctp_chunk_to_string (chunk_type),
-		 sctp_state_to_string (tc0->state));
+		 sctp_state_to_string (sctp_conn->state));
 	      break;
 	    }
 
 	  if (chunk_type == SHUTDOWN)
 	    {
 	      /* Start the SCTP_TIMER_T2_SHUTDOWN timer */
-	      sctp_timer_set (tc0, idx, SCTP_TIMER_T2_SHUTDOWN,
+	      sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN,
 			      SCTP_RTO_INIT);
-	      tc0->state = SCTP_STATE_SHUTDOWN_SENT;
+	      sctp_conn->state = SCTP_STATE_SHUTDOWN_SENT;
+	    }
+
+	  if (chunk_type == DATA)
+	    {
+	      sctp_timer_update (sctp_conn, idx, SCTP_TIMER_T3_RXTX,
+				 SCTP_RTO_INIT);
 	    }
 
 	  vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
@@ -1231,8 +1329,8 @@ sctp46_output_inline (vlib_main_t * vm,
 	  SCTP_DBG_STATE_MACHINE ("CONNECTION_INDEX = %u, "
 				  "NEW_STATE = %s, "
 				  "CHUNK_SENT = %s",
-				  tc0->sub_conn[idx].connection.c_index,
-				  sctp_state_to_string (tc0->state),
+				  sctp_conn->sub_conn[idx].connection.c_index,
+				  sctp_state_to_string (sctp_conn->state),
 				  sctp_chunk_to_string (chunk_type));
 
 	  vnet_sctp_common_hdr_params_host_to_net (&full_hdr->common_hdr);
@@ -1251,7 +1349,7 @@ sctp46_output_inline (vlib_main_t * vm,
 		{
 		  memset (&t0->sctp_header, 0, sizeof (t0->sctp_header));
 		}
-	      clib_memcpy (&t0->sctp_connection, tc0,
+	      clib_memcpy (&t0->sctp_connection, sctp_conn,
 			   sizeof (t0->sctp_connection));
 	    }
 
diff --git a/src/vnet/sctp/sctp_packet.h b/src/vnet/sctp/sctp_packet.h
index 4c358db6d3b..d1fe7ab71ea 100644
--- a/src/vnet/sctp/sctp_packet.h
+++ b/src/vnet/sctp/sctp_packet.h
@@ -503,17 +503,6 @@ vnet_sctp_calculate_padding (u16 base_length)
   return (4 - base_length % 4);
 }
 
-always_inline u16
-vnet_sctp_calculate_payload_data_padding (sctp_payload_data_chunk_t * p)
-{
-  u16 payload_length = vnet_sctp_get_chunk_length (&p->chunk_hdr) -
-    sizeof (p->chunk_hdr) -
-    sizeof (p->tsn) -
-    sizeof (p->stream_id) - sizeof (p->stream_seq) - sizeof (p->payload_id);
-
-  return vnet_sctp_calculate_padding (payload_length);
-}
-
 #define DEFAULT_A_RWND 1480
 #define INBOUND_STREAMS_COUNT 1
 #define OUTBOUND_STREAMS_COUNT 1