src/vnet/sctp/sctp.c

   1 /*
   2  * Copyright (c) 2017 SUSE LLC.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 #include <vnet/sctp/sctp.h>
  16 #include <vnet/sctp/sctp_debug.h>
  17
  18 sctp_main_t sctp_main;
  19
  20 static u32
  21 sctp_connection_bind (u32 session_index, transport_endpoint_t * tep)
  22 {
  23   sctp_main_t *tm = &sctp_main;
  24   sctp_connection_t *listener;
  25   void *iface_ip;
  26
  27   pool_get (tm->listener_pool, listener);
  28   clib_memset (listener, 0, sizeof (*listener));
  29
  30   listener->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
  31     SCTP_PRIMARY_PATH_IDX;
  32   listener->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
  33     listener - tm->listener_pool;
  34   listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.lcl_port = tep->port;
  35
  36   /* If we are provided a sw_if_index, bind using one of its IPs */
  37   if (ip_is_zero (&tep->ip, 1) && tep->sw_if_index != ENDPOINT_INVALID_INDEX)
  38     {
  39       if ((iface_ip = ip_interface_get_first_ip (tep->sw_if_index,
  40                                                  tep->is_ip4)))
  41         ip_set (&tep->ip, iface_ip, tep->is_ip4);
  42     }
  43   ip_copy (&listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.lcl_ip,
  44            &tep->ip, tep->is_ip4);
  45
  46   u32 mtu = tep->is_ip4 ? vnet_sw_interface_get_mtu (vnet_get_main (),
  47                                                      tep->sw_if_index,
  48                                                      VNET_MTU_IP4) :
  49     vnet_sw_interface_get_mtu (vnet_get_main (), tep->sw_if_index,
  50                                VNET_MTU_IP6);
  51   listener->sub_conn[SCTP_PRIMARY_PATH_IDX].PMTU = mtu;
  52   listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.is_ip4 = tep->is_ip4;
  53   listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.proto =
  54     TRANSPORT_PROTO_SCTP;
  55   listener->sub_conn[SCTP_PRIMARY_PATH_IDX].c_s_index = session_index;
  56   listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.fib_index =
  57     tep->fib_index;
  58   listener->state = SCTP_STATE_CLOSED;
  59
  60   sctp_connection_timers_init (listener);
  61
  62   return listener->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index;
  63 }
  64
  65 u32
  66 sctp_session_bind (u32 session_index, transport_endpoint_t * tep)
  67 {
  68   return sctp_connection_bind (session_index, tep);
  69 }
  70
  71 static void
  72 sctp_connection_unbind (u32 listener_index)
  73 {
  74   sctp_main_t *tm = vnet_get_sctp_main ();
  75   sctp_connection_t *sctp_conn;
  76
  77   sctp_conn = pool_elt_at_index (tm->listener_pool, listener_index);
  78
  79   /* Poison the entry */
  80   if (CLIB_DEBUG > 0)
  81     clib_memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
  82
  83   pool_put_index (tm->listener_pool, listener_index);
  84 }
  85
  86 u32
  87 sctp_session_unbind (u32 listener_index)
  88 {
  89   sctp_connection_unbind (listener_index);
  90   return 0;
  91 }
  92
  93 void
  94 sctp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add)
  95 {
  96   sctp_main_t *tm = &sctp_main;
  97   if (is_ip4)
  98     tm->punt_unknown4 = is_add;
  99   else
 100     tm->punt_unknown6 = is_add;
 101 }
 102
 103 static int
 104 sctp_alloc_custom_local_endpoint (sctp_main_t * tm, ip46_address_t * lcl_addr,
 105                                   u16 * lcl_port, u8 is_ip4)
 106 {
 107   int index, port;
 108   if (is_ip4)
 109     {
 110       index = tm->last_v4_address_rotor++;
 111       if (tm->last_v4_address_rotor >= vec_len (tm->ip4_src_addresses))
 112         tm->last_v4_address_rotor = 0;
 113       lcl_addr->ip4.as_u32 = tm->ip4_src_addresses[index].as_u32;
 114     }
 115   else
 116     {
 117       index = tm->last_v6_address_rotor++;
 118       if (tm->last_v6_address_rotor >= vec_len (tm->ip6_src_addresses))
 119         tm->last_v6_address_rotor = 0;
 120       clib_memcpy (&lcl_addr->ip6, &tm->ip6_src_addresses[index],
 121                    sizeof (ip6_address_t));
 122     }
 123   port = transport_alloc_local_port (TRANSPORT_PROTO_SCTP, lcl_addr);
 124   if (port < 1)
 125     {
 126       clib_warning ("Failed to allocate src port");
 127       return -1;
 128     }
 129   *lcl_port = port;
 130   return 0;
 131 }
 132
 133 /**
 134  * Initialize all connection timers as invalid
 135  */
 136 void
 137 sctp_connection_timers_init (sctp_connection_t * sctp_conn)
 138 {
 139   int i, j;
 140
 141   /* Set all to invalid */
 142   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 143     {
 144       sctp_conn->sub_conn[i].RTO = SCTP_RTO_INIT;
 145
 146       for (j = 0; j < SCTP_N_TIMERS; j++)
 147         {
 148           sctp_conn->sub_conn[i].timers[j] = SCTP_TIMER_HANDLE_INVALID;
 149         }
 150     }
 151 }
 152
 153 /**
 154  * Stop all connection timers
 155  */
 156 void
 157 sctp_connection_timers_reset (sctp_connection_t * sctp_conn)
 158 {
 159   int i, j;
 160   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 161     {
 162       for (j = 0; j < SCTP_N_TIMERS; j++)
 163         sctp_timer_reset (sctp_conn, i, j);
 164     }
 165 }
 166
 167 const char *sctp_fsm_states[] = {
 168 #define _(sym, str) str,
 169   foreach_sctp_fsm_state
 170 #undef _
 171 };
 172
 173 u8 *
 174 format_sctp_state (u8 * s, va_list * args)
 175 {
 176   u32 state = va_arg (*args, u32);
 177
 178   if (state < SCTP_N_STATES)
 179     s = format (s, "%s", sctp_fsm_states[state]);
 180   else
 181     s = format (s, "UNKNOWN (%d (0x%x))", state, state);
 182   return s;
 183 }
 184
 185 u8 *
 186 format_sctp_connection_id (u8 * s, va_list * args)
 187 {
 188   sctp_connection_t *sctp_conn = va_arg (*args, sctp_connection_t *);
 189   if (!sctp_conn)
 190     return s;
 191
 192   u8 i;
 193   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 194     {
 195       if (sctp_conn->sub_conn[i].connection.is_ip4)
 196         {
 197           s = format (s, "%U[#%d][%s] %U:%d->%U:%d",
 198                       s,
 199                       sctp_conn->sub_conn[i].connection.thread_index,
 200                       "T",
 201                       format_ip4_address,
 202                       &sctp_conn->sub_conn[i].connection.lcl_ip.ip4,
 203                       clib_net_to_host_u16 (sctp_conn->sub_conn[i].
 204                                             connection.lcl_port),
 205                       format_ip4_address,
 206                       &sctp_conn->sub_conn[i].connection.rmt_ip.ip4,
 207                       clib_net_to_host_u16 (sctp_conn->sub_conn[i].
 208                                             connection.rmt_port));
 209         }
 210       else
 211         {
 212           s = format (s, "%U[#%d][%s] %U:%d->%U:%d",
 213                       s,
 214                       sctp_conn->sub_conn[i].connection.thread_index,
 215                       "T",
 216                       format_ip6_address,
 217                       &sctp_conn->sub_conn[i].connection.lcl_ip.ip6,
 218                       clib_net_to_host_u16 (sctp_conn->sub_conn[i].
 219                                             connection.lcl_port),
 220                       format_ip6_address,
 221                       &sctp_conn->sub_conn[i].connection.rmt_ip.ip6,
 222                       clib_net_to_host_u16 (sctp_conn->sub_conn[i].
 223                                             connection.rmt_port));
 224         }
 225     }
 226   return s;
 227 }
 228
 229 u8 *
 230 format_sctp_connection (u8 * s, va_list * args)
 231 {
 232   sctp_connection_t *sctp_conn = va_arg (*args, sctp_connection_t *);
 233   u32 verbose = va_arg (*args, u32);
 234
 235   if (!sctp_conn)
 236     return s;
 237   s = format (s, "%-50U", format_sctp_connection_id, sctp_conn);
 238   if (verbose)
 239     {
 240       s = format (s, "%-15U", format_sctp_state, sctp_conn->state);
 241     }
 242
 243   return s;
 244 }
 245
 246 /**
 247  * Initialize connection send variables.
 248  */
 249 void
 250 sctp_init_snd_vars (sctp_connection_t * sctp_conn)
 251 {
 252   u32 time_now;
 253   /*
 254    * We use the time to randomize iss and for setting up the initial
 255    * timestamp. Make sure it's updated otherwise syn and ack in the
 256    * handshake may make it look as if time has flown in the opposite
 257    * direction for us.
 258    */
 259
 260   sctp_set_time_now (vlib_get_thread_index ());
 261   time_now = sctp_time_now ();
 262
 263   sctp_conn->local_initial_tsn = random_u32 (&time_now);
 264   sctp_conn->last_unacked_tsn = sctp_conn->local_initial_tsn;
 265   sctp_conn->next_tsn = sctp_conn->local_initial_tsn + 1;
 266
 267   sctp_conn->remote_initial_tsn = 0x0;
 268   sctp_conn->last_rcvd_tsn = sctp_conn->remote_initial_tsn;
 269 }
 270
 271 always_inline sctp_connection_t *
 272 sctp_sub_connection_add (u8 thread_index)
 273 {
 274   sctp_main_t *tm = vnet_get_sctp_main ();
 275   sctp_connection_t *sctp_conn = tm->connections[thread_index];
 276
 277   u8 subconn_idx = sctp_next_avail_subconn (sctp_conn);
 278
 279   ASSERT (subconn_idx < MAX_SCTP_CONNECTIONS);
 280
 281   sctp_conn->sub_conn[subconn_idx].connection.c_index =
 282     sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.c_index;
 283   sctp_conn->sub_conn[subconn_idx].connection.thread_index = thread_index;
 284   sctp_conn->sub_conn[subconn_idx].subconn_idx = subconn_idx;
 285
 286   return sctp_conn;
 287 }
 288
 289 u8
 290 sctp_sub_connection_add_ip4 (vlib_main_t * vm,
 291                              ip4_address_t * lcl_addr,
 292                              ip4_address_t * rmt_addr)
 293 {
 294   sctp_connection_t *sctp_conn = sctp_sub_connection_add (vm->thread_index);
 295
 296   u8 subconn_idx = sctp_next_avail_subconn (sctp_conn);
 297
 298   if (subconn_idx == MAX_SCTP_CONNECTIONS)
 299     return SCTP_ERROR_MAX_CONNECTIONS;
 300
 301   clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.lcl_ip,
 302                &lcl_addr, sizeof (lcl_addr));
 303
 304   clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.rmt_ip,
 305                &rmt_addr, sizeof (rmt_addr));
 306
 307   sctp_conn->forming_association_changed = 1;
 308
 309   return SCTP_ERROR_NONE;
 310 }
 311
 312 u8
 313 sctp_sub_connection_del_ip4 (ip4_address_t * lcl_addr,
 314                              ip4_address_t * rmt_addr)
 315 {
 316   sctp_main_t *sctp_main = vnet_get_sctp_main ();
 317
 318   u32 thread_idx = vlib_get_thread_index ();
 319   u8 i;
 320
 321   ASSERT (thread_idx == 0);
 322
 323   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 324     {
 325       sctp_connection_t *sctp_conn = sctp_main->connections[thread_idx];
 326       sctp_sub_connection_t *sub_conn =
 327         &sctp_main->connections[thread_idx]->sub_conn[i];
 328       ip46_address_t *lcl_ip =
 329         &sctp_main->connections[thread_idx]->sub_conn[i].connection.lcl_ip;
 330       ip46_address_t *rmt_ip =
 331         &sctp_main->connections[thread_idx]->sub_conn[i].connection.rmt_ip;
 332
 333       if (!sub_conn->connection.is_ip4)
 334         continue;
 335       if (lcl_ip->ip4.as_u32 == lcl_addr->as_u32 &&
 336           rmt_ip->ip4.as_u32 == rmt_addr->as_u32)
 337         {
 338           sub_conn->state = SCTP_SUBCONN_STATE_DOWN;
 339           sctp_conn->forming_association_changed = 1;
 340           break;
 341         }
 342     }
 343   return SCTP_ERROR_NONE;
 344 }
 345
 346 u8
 347 sctp_sub_connection_add_ip6 (vlib_main_t * vm,
 348                              ip6_address_t * lcl_addr,
 349                              ip6_address_t * rmt_addr)
 350 {
 351   sctp_connection_t *sctp_conn = sctp_sub_connection_add (vm->thread_index);
 352
 353   u8 subconn_idx = sctp_next_avail_subconn (sctp_conn);
 354
 355   if (subconn_idx == MAX_SCTP_CONNECTIONS)
 356     return SCTP_ERROR_MAX_CONNECTIONS;
 357
 358   clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.lcl_ip,
 359                &lcl_addr, sizeof (lcl_addr));
 360
 361   clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.rmt_ip,
 362                &rmt_addr, sizeof (rmt_addr));
 363
 364   sctp_conn->forming_association_changed = 1;
 365
 366   return SCTP_ERROR_NONE;
 367 }
 368
 369 u8
 370 sctp_sub_connection_del_ip6 (ip6_address_t * lcl_addr,
 371                              ip6_address_t * rmt_addr)
 372 {
 373   sctp_main_t *sctp_main = vnet_get_sctp_main ();
 374
 375   u32 thread_idx = vlib_get_thread_index ();
 376   u8 i;
 377
 378   ASSERT (thread_idx == 0);
 379
 380   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 381     {
 382       sctp_connection_t *sctp_conn = sctp_main->connections[thread_idx];
 383       sctp_sub_connection_t *sub_conn =
 384         &sctp_main->connections[thread_idx]->sub_conn[i];
 385       ip46_address_t *lcl_ip =
 386         &sctp_main->connections[thread_idx]->sub_conn[i].connection.lcl_ip;
 387       ip46_address_t *rmt_ip =
 388         &sctp_main->connections[thread_idx]->sub_conn[i].connection.rmt_ip;
 389
 390       if (!sub_conn->connection.is_ip4)
 391         continue;
 392       if ((lcl_ip->ip6.as_u64[0] == lcl_addr->as_u64[0]
 393            && lcl_ip->ip6.as_u64[1] == lcl_addr->as_u64[1])
 394           && (rmt_ip->ip6.as_u64[0] == rmt_addr->as_u64[0]
 395               && rmt_ip->ip6.as_u64[1] == rmt_addr->as_u64[1]))
 396         {
 397           sub_conn->state = SCTP_SUBCONN_STATE_DOWN;
 398           sctp_conn->forming_association_changed = 1;
 399           break;
 400         }
 401     }
 402   return SCTP_ERROR_NONE;
 403 }
 404
 405 u8
 406 sctp_configure (sctp_user_configuration_t config)
 407 {
 408   sctp_main_t *sctp_main = vnet_get_sctp_main ();
 409
 410   u32 thread_idx = vlib_get_thread_index ();
 411
 412   sctp_main->connections[thread_idx]->conn_config.never_delay_sack =
 413     config.never_delay_sack;
 414   sctp_main->connections[thread_idx]->conn_config.never_bundle =
 415     config.never_bundle;
 416
 417   return 0;
 418 }
 419
 420 sctp_connection_t *
 421 sctp_connection_new (u8 thread_index)
 422 {
 423   sctp_main_t *sctp_main = vnet_get_sctp_main ();
 424   sctp_connection_t *sctp_conn;
 425
 426   pool_get (sctp_main->connections[thread_index], sctp_conn);
 427   clib_memset (sctp_conn, 0, sizeof (*sctp_conn));
 428   sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
 429     SCTP_PRIMARY_PATH_IDX;
 430   sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
 431     sctp_conn - sctp_main->connections[thread_index];
 432   sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_thread_index = thread_index;
 433   sctp_conn->local_tag = 0;
 434
 435   return sctp_conn;
 436 }
 437
 438 sctp_connection_t *
 439 sctp_half_open_connection_new (u8 thread_index)
 440 {
 441   sctp_main_t *tm = vnet_get_sctp_main ();
 442   sctp_connection_t *sctp_conn = 0;
 443   ASSERT (vlib_get_thread_index () == 0);
 444   pool_get (tm->half_open_connections, sctp_conn);
 445   clib_memset (sctp_conn, 0, sizeof (*sctp_conn));
 446   sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
 447     sctp_conn - tm->half_open_connections;
 448   sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
 449     SCTP_PRIMARY_PATH_IDX;
 450   return sctp_conn;
 451 }
 452
 453 static inline int
 454 sctp_connection_open (transport_endpoint_t * rmt)
 455 {
 456   sctp_main_t *tm = vnet_get_sctp_main ();
 457   sctp_connection_t *sctp_conn;
 458   ip46_address_t lcl_addr;
 459   u16 lcl_port;
 460   uword thread_id;
 461   int rv;
 462
 463   u8 idx = SCTP_PRIMARY_PATH_IDX;
 464
 465   /*
 466    * Allocate local endpoint
 467    */
 468   if ((rmt->is_ip4 && vec_len (tm->ip4_src_addresses))
 469       || (!rmt->is_ip4 && vec_len (tm->ip6_src_addresses)))
 470     rv = sctp_alloc_custom_local_endpoint (tm, &lcl_addr, &lcl_port,
 471                                            rmt->is_ip4);
 472   else
 473     rv = transport_alloc_local_endpoint (TRANSPORT_PROTO_SCTP,
 474                                          rmt, &lcl_addr, &lcl_port);
 475
 476   if (rv)
 477     return -1;
 478
 479   /*
 480    * Create connection and send INIT CHUNK
 481    */
 482   thread_id = vlib_get_thread_index ();
 483   ASSERT (thread_id == 0);
 484
 485   clib_spinlock_lock_if_init (&tm->half_open_lock);
 486   sctp_conn = sctp_half_open_connection_new (thread_id);
 487   u32 mtu = rmt->is_ip4 ? vnet_sw_interface_get_mtu (vnet_get_main (),
 488                                                      rmt->sw_if_index,
 489                                                      VNET_MTU_IP4) :
 490     vnet_sw_interface_get_mtu (vnet_get_main (), rmt->sw_if_index,
 491                                VNET_MTU_IP6);
 492   sctp_conn->sub_conn[idx].PMTU = mtu;
 493
 494   transport_connection_t *trans_conn = &sctp_conn->sub_conn[idx].connection;
 495   ip_copy (&trans_conn->rmt_ip, &rmt->ip, rmt->is_ip4);
 496   ip_copy (&trans_conn->lcl_ip, &lcl_addr, rmt->is_ip4);
 497   sctp_conn->sub_conn[idx].subconn_idx = idx;
 498   trans_conn->rmt_port = rmt->port;
 499   trans_conn->lcl_port = clib_host_to_net_u16 (lcl_port);
 500   trans_conn->is_ip4 = rmt->is_ip4;
 501   trans_conn->proto = TRANSPORT_PROTO_SCTP;
 502   trans_conn->fib_index = rmt->fib_index;
 503
 504   sctp_connection_timers_init (sctp_conn);
 505   /* The other connection vars will be initialized after INIT_ACK chunk received */
 506   sctp_init_snd_vars (sctp_conn);
 507
 508   sctp_send_init (sctp_conn);
 509
 510   clib_spinlock_unlock_if_init (&tm->half_open_lock);
 511
 512   return sctp_conn->sub_conn[idx].connection.c_index;
 513 }
 514
 515 /**
 516  * Cleans up connection state.
 517  *
 518  * No notifications.
 519  */
 520 void
 521 sctp_connection_cleanup (sctp_connection_t * sctp_conn)
 522 {
 523   sctp_main_t *tm = &sctp_main;
 524   u8 i;
 525
 526   /* Cleanup local endpoint if this was an active connect */
 527   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 528     transport_endpoint_cleanup (TRANSPORT_PROTO_SCTP,
 529                                 &sctp_conn->sub_conn[i].connection.lcl_ip,
 530                                 sctp_conn->sub_conn[i].connection.lcl_port);
 531
 532   int thread_index =
 533     sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.thread_index;
 534
 535   /* Make sure all timers are cleared */
 536   sctp_connection_timers_reset (sctp_conn);
 537
 538   /* Poison the entry */
 539   if (CLIB_DEBUG > 0)
 540     clib_memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
 541   pool_put (tm->connections[thread_index], sctp_conn);
 542 }
 543
 544 int
 545 sctp_session_open (transport_endpoint_t * tep)
 546 {
 547   return sctp_connection_open (tep);
 548 }
 549
 550 u16
 551 sctp_check_outstanding_data_chunks (sctp_connection_t * sctp_conn)
 552 {
 553   u8 i;
 554   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 555     {
 556       if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
 557         continue;
 558
 559       if (sctp_conn->sub_conn[i].is_retransmitting == 1 ||
 560           sctp_conn->sub_conn[i].enqueue_state != SCTP_ERROR_ENQUEUED)
 561         {
 562           SCTP_DBG_OUTPUT
 563             ("Connection %u has still DATA to be enqueued inboud / outboud",
 564              sctp_conn->sub_conn[i].connection.c_index);
 565           return 1;
 566         }
 567
 568     }
 569   return 0;                     /* Indicates no more data to be read/sent */
 570 }
 571
 572 void
 573 sctp_connection_close (sctp_connection_t * sctp_conn)
 574 {
 575   SCTP_DBG ("Closing connection %u...",
 576             sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.c_index);
 577
 578   sctp_conn->state = SCTP_STATE_SHUTDOWN_PENDING;
 579
 580   sctp_send_shutdown (sctp_conn);
 581 }
 582
 583 void
 584 sctp_session_close (u32 conn_index, u32 thread_index)
 585 {
 586   ASSERT (thread_index == 0);
 587
 588   sctp_connection_t *sctp_conn =
 589     sctp_connection_get (conn_index, thread_index);
 590   if (sctp_conn != NULL)
 591     sctp_connection_close (sctp_conn);
 592 }
 593
 594 void
 595 sctp_session_cleanup (u32 conn_index, u32 thread_index)
 596 {
 597   sctp_connection_t *sctp_conn =
 598     sctp_connection_get (conn_index, thread_index);
 599
 600   if (sctp_conn != NULL)
 601     {
 602       sctp_connection_timers_reset (sctp_conn);
 603       /* Wait for the session tx events to clear */
 604       sctp_conn->state = SCTP_STATE_CLOSED;
 605     }
 606 }
 607
 608 /**
 609  * Compute maximum segment size for session layer.
 610  */
 611 u16
 612 sctp_session_send_mss (transport_connection_t * trans_conn)
 613 {
 614   sctp_connection_t *sctp_conn =
 615     sctp_get_connection_from_transport (trans_conn);
 616
 617   if (sctp_conn == NULL)
 618     {
 619       SCTP_DBG ("sctp_conn == NULL");
 620       return 0;
 621     }
 622
 623   update_cwnd (sctp_conn);
 624   update_smallest_pmtu_idx (sctp_conn);
 625
 626   u8 idx = sctp_data_subconn_select (sctp_conn);
 627
 628   return sctp_conn->sub_conn[idx].cwnd;
 629 }
 630
 631 u16
 632 sctp_snd_space (sctp_connection_t * sctp_conn)
 633 {
 634   /* RFC 4096 Section 6.1; point (A) */
 635   if (sctp_conn->peer_rwnd == 0)
 636     return 0;
 637
 638   u8 idx = sctp_data_subconn_select (sctp_conn);
 639
 640   u32 available_wnd =
 641     clib_min (sctp_conn->peer_rwnd, sctp_conn->sub_conn[idx].cwnd);
 642   int flight_size = (int) (sctp_conn->next_tsn - sctp_conn->last_unacked_tsn);
 643
 644   if (available_wnd <= flight_size)
 645     return 0;
 646
 647   /* Finally, let's subtract the DATA chunk headers overhead */
 648   return available_wnd -
 649     flight_size -
 650     sizeof (sctp_payload_data_chunk_t) - sizeof (sctp_full_hdr_t);
 651 }
 652
 653 /**
 654  * Compute TX window session is allowed to fill.
 655  */
 656 u32
 657 sctp_session_send_space (transport_connection_t * trans_conn)
 658 {
 659   sctp_connection_t *sctp_conn =
 660     sctp_get_connection_from_transport (trans_conn);
 661
 662   return sctp_snd_space (sctp_conn);
 663 }
 664
 665 transport_connection_t *
 666 sctp_session_get_transport (u32 conn_index, u32 thread_index)
 667 {
 668   sctp_connection_t *sctp_conn =
 669     sctp_connection_get (conn_index, thread_index);
 670
 671   if (PREDICT_TRUE (sctp_conn != NULL))
 672     return &sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection;
 673
 674   return NULL;
 675 }
 676
 677 transport_connection_t *
 678 sctp_session_get_listener (u32 listener_index)
 679 {
 680   sctp_main_t *tm = vnet_get_sctp_main ();
 681   sctp_connection_t *sctp_conn;
 682   sctp_conn = pool_elt_at_index (tm->listener_pool, listener_index);
 683   return &sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection;
 684 }
 685
 686 u8 *
 687 format_sctp_session (u8 * s, va_list * args)
 688 {
 689   u32 tci = va_arg (*args, u32);
 690   u32 thread_index = va_arg (*args, u32);
 691   u32 verbose = va_arg (*args, u32);
 692   sctp_connection_t *tc;
 693
 694   tc = sctp_connection_get (tci, thread_index);
 695   if (tc)
 696     s = format (s, "%U", format_sctp_connection, tc, verbose);
 697   else
 698     s = format (s, "empty\n");
 699   return s;
 700 }
 701
 702 u8 *
 703 format_sctp_listener_session (u8 * s, va_list * args)
 704 {
 705   u32 tci = va_arg (*args, u32);
 706   sctp_connection_t *tc = sctp_listener_get (tci);
 707   return format (s, "%U", format_sctp_connection_id, tc);
 708 }
 709
 710 void
 711 sctp_expired_timers_cb (u32 conn_index, u32 timer_id)
 712 {
 713   sctp_connection_t *sctp_conn;
 714
 715   SCTP_DBG ("%s expired", sctp_timer_to_string (timer_id));
 716
 717   sctp_conn = sctp_connection_get (conn_index, vlib_get_thread_index ());
 718   /* note: the connection may have already disappeared */
 719   if (PREDICT_FALSE (sctp_conn == 0))
 720     return;
 721
 722   if (sctp_conn->sub_conn[conn_index].unacknowledged_hb >
 723       SCTP_PATH_MAX_RETRANS)
 724     {
 725       // The remote-peer is considered to be unreachable hence shutting down
 726       u8 i, total_subs_down = 1;
 727       for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 728         {
 729           if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
 730             continue;
 731
 732           u32 now = sctp_time_now ();
 733           if (now > (sctp_conn->sub_conn[i].last_seen + SCTP_HB_INTERVAL))
 734             {
 735               total_subs_down += 1;
 736               sctp_conn->sub_conn[i].state = SCTP_SUBCONN_STATE_DOWN;
 737             }
 738         }
 739
 740       if (total_subs_down == MAX_SCTP_CONNECTIONS)
 741         {
 742           /* Start cleanup. App wasn't notified yet so use delete notify as
 743            * opposed to delete to cleanup session layer state. */
 744           stream_session_delete_notify (&sctp_conn->sub_conn
 745                                         [SCTP_PRIMARY_PATH_IDX].connection);
 746
 747           sctp_connection_timers_reset (sctp_conn);
 748
 749           sctp_connection_cleanup (sctp_conn);
 750         }
 751       return;
 752     }
 753
 754   switch (timer_id)
 755     {
 756     case SCTP_TIMER_T1_INIT:
 757       sctp_send_init (sctp_conn);
 758       break;
 759     case SCTP_TIMER_T1_COOKIE:
 760       sctp_send_cookie_echo (sctp_conn);
 761       break;
 762     case SCTP_TIMER_T2_SHUTDOWN:
 763       sctp_send_shutdown (sctp_conn);
 764       break;
 765     case SCTP_TIMER_T3_RXTX:
 766       sctp_timer_reset (sctp_conn, conn_index, timer_id);
 767       sctp_conn->flags |= SCTP_CONN_RECOVERY;
 768       sctp_data_retransmit (sctp_conn);
 769       break;
 770     case SCTP_TIMER_T4_HEARTBEAT:
 771       sctp_timer_reset (sctp_conn, conn_index, timer_id);
 772       goto heartbeat;
 773     }
 774   return;
 775
 776 heartbeat:
 777   sctp_send_heartbeat (sctp_conn);
 778 }
 779
 780 static void
 781 sctp_expired_timers_dispatch (u32 * expired_timers)
 782 {
 783   int i;
 784   u32 connection_index, timer_id;
 785
 786   for (i = 0; i < vec_len (expired_timers); i++)
 787     {
 788       /* Get session index and timer id */
 789       connection_index = expired_timers[i] & 0x0FFFFFFF;
 790       timer_id = expired_timers[i] >> 28;
 791
 792       SCTP_DBG ("Expired timer ID: %u", timer_id);
 793
 794       /* Handle expiration */
 795       sctp_expired_timers_cb (connection_index, timer_id);
 796     }
 797 }
 798
 799 void
 800 sctp_initialize_timer_wheels (sctp_main_t * tm)
 801 {
 802   tw_timer_wheel_16t_2w_512sl_t *tw;
 803   /* *INDENT-OFF* */
 804   foreach_vlib_main (({
 805     tw = &tm->timer_wheels[ii];
 806     tw_timer_wheel_init_16t_2w_512sl (tw, sctp_expired_timers_dispatch,
 807                                       100e-3 /* timer period 100ms */ , ~0);
 808     tw->last_run_time = vlib_time_now (this_vlib_main);
 809   }));
 810   /* *INDENT-ON* */
 811 }
 812
 813 clib_error_t *
 814 sctp_main_enable (vlib_main_t * vm)
 815 {
 816   sctp_main_t *tm = vnet_get_sctp_main ();
 817   vlib_thread_main_t *vtm = vlib_get_thread_main ();
 818   clib_error_t *error = 0;
 819   u32 num_threads;
 820   int thread;
 821   sctp_connection_t *sctp_conn __attribute__ ((unused));
 822   u32 preallocated_connections_per_thread;
 823
 824   if ((error = vlib_call_init_function (vm, ip_main_init)))
 825     return error;
 826   if ((error = vlib_call_init_function (vm, ip4_lookup_init)))
 827     return error;
 828   if ((error = vlib_call_init_function (vm, ip6_lookup_init)))
 829     return error;
 830
 831   /*
 832    * Registrations
 833    */
 834
 835   ip4_register_protocol (IP_PROTOCOL_SCTP, sctp4_input_node.index);
 836   ip6_register_protocol (IP_PROTOCOL_SCTP, sctp6_input_node.index);
 837
 838   /*
 839    * Initialize data structures
 840    */
 841
 842   num_threads = 1 /* main thread */  + vtm->n_threads;
 843   vec_validate (tm->connections, num_threads - 1);
 844
 845   /*
 846    * Preallocate connections. Assume that thread 0 won't
 847    * use preallocated threads when running multi-core
 848    */
 849   if (num_threads == 1)
 850     {
 851       thread = 0;
 852       preallocated_connections_per_thread = tm->preallocated_connections;
 853     }
 854   else
 855     {
 856       thread = 1;
 857       preallocated_connections_per_thread =
 858         tm->preallocated_connections / (num_threads - 1);
 859     }
 860   for (; thread < num_threads; thread++)
 861     {
 862       if (preallocated_connections_per_thread)
 863         pool_init_fixed (tm->connections[thread],
 864                          preallocated_connections_per_thread);
 865     }
 866
 867   /* Initialize per worker thread tx buffers (used for control messages) */
 868   vec_validate (tm->tx_buffers, num_threads - 1);
 869
 870   /* Initialize timer wheels */
 871   vec_validate (tm->timer_wheels, num_threads - 1);
 872   sctp_initialize_timer_wheels (tm);
 873
 874   /* Initialize clocks per tick for SCTP timestamp. Used to compute
 875    * monotonically increasing timestamps. */
 876   tm->tstamp_ticks_per_clock = vm->clib_time.seconds_per_clock
 877     / SCTP_TSTAMP_RESOLUTION;
 878
 879   if (num_threads > 1)
 880     {
 881       clib_spinlock_init (&tm->half_open_lock);
 882     }
 883
 884   vec_validate (tm->tx_frames[0], num_threads - 1);
 885   vec_validate (tm->tx_frames[1], num_threads - 1);
 886   vec_validate (tm->ip_lookup_tx_frames[0], num_threads - 1);
 887   vec_validate (tm->ip_lookup_tx_frames[1], num_threads - 1);
 888
 889   tm->bytes_per_buffer = vlib_buffer_free_list_buffer_size
 890     (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
 891
 892   vec_validate (tm->time_now, num_threads - 1);
 893   return error;
 894 }
 895
 896 clib_error_t *
 897 sctp_enable_disable (vlib_main_t * vm, u8 is_en)
 898 {
 899   if (is_en)
 900     {
 901       if (sctp_main.is_enabled)
 902         return 0;
 903
 904       return sctp_main_enable (vm);
 905     }
 906   else
 907     {
 908       sctp_main.is_enabled = 0;
 909     }
 910
 911   return 0;
 912 }
 913
 914 transport_connection_t *
 915 sctp_half_open_session_get_transport (u32 conn_index)
 916 {
 917   sctp_connection_t *sctp_conn = sctp_half_open_connection_get (conn_index);
 918   return &sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection;
 919 }
 920
 921 u8 *
 922 format_sctp_half_open (u8 * s, va_list * args)
 923 {
 924   u32 tci = va_arg (*args, u32);
 925   sctp_connection_t *sctp_conn = sctp_half_open_connection_get (tci);
 926   return format (s, "%U", format_sctp_connection_id, sctp_conn);
 927 }
 928
 929 void
 930 sctp_update_time (f64 now, u8 thread_index)
 931 {
 932   sctp_set_time_now (thread_index);
 933   tw_timer_expire_timers_16t_2w_512sl (&sctp_main.timer_wheels[thread_index],
 934                                        now);
 935   sctp_flush_frames_to_output (thread_index);
 936 }
 937
 938 /* *INDENT OFF* */
 939 const static transport_proto_vft_t sctp_proto = {
 940   .enable = sctp_enable_disable,
 941   .bind = sctp_session_bind,
 942   .unbind = sctp_session_unbind,
 943   .open = sctp_session_open,
 944   .close = sctp_session_close,
 945   .cleanup = sctp_session_cleanup,
 946   .push_header = sctp_push_header,
 947   .send_mss = sctp_session_send_mss,
 948   .send_space = sctp_session_send_space,
 949   .update_time = sctp_update_time,
 950   .get_connection = sctp_session_get_transport,
 951   .get_listener = sctp_session_get_listener,
 952   .get_half_open = sctp_half_open_session_get_transport,
 953   .format_connection = format_sctp_session,
 954   .format_listener = format_sctp_listener_session,
 955   .format_half_open = format_sctp_half_open,
 956   .tx_type = TRANSPORT_TX_DEQUEUE,
 957   .service_type = TRANSPORT_SERVICE_VC,
 958 };
 959
 960 /* *INDENT ON* */
 961
 962 clib_error_t *
 963 sctp_init (vlib_main_t * vm)
 964 {
 965   sctp_main_t *tm = vnet_get_sctp_main ();
 966   ip_main_t *im = &ip_main;
 967   ip_protocol_info_t *pi;
 968   /* Session layer, and by implication SCTP, are disabled by default */
 969   tm->is_enabled = 0;
 970
 971   /* Register with IP for header parsing */
 972   pi = ip_get_protocol_info (im, IP_PROTOCOL_SCTP);
 973   if (pi == 0)
 974     return clib_error_return (0, "SCTP protocol info AWOL");
 975   pi->format_header = format_sctp_header;
 976   pi->unformat_pg_edit = unformat_pg_sctp_header;
 977
 978   /* Register as transport with session layer */
 979   transport_register_protocol (TRANSPORT_PROTO_SCTP, &sctp_proto,
 980                                FIB_PROTOCOL_IP4, sctp4_output_node.index);
 981   transport_register_protocol (TRANSPORT_PROTO_SCTP, &sctp_proto,
 982                                FIB_PROTOCOL_IP6, sctp6_output_node.index);
 983
 984   sctp_api_reference ();
 985
 986   return 0;
 987 }
 988
 989 VLIB_INIT_FUNCTION (sctp_init);
 990
 991 /*
 992  * fd.io coding-style-patch-verification: ON
 993  *
 994  * Local Variables:
 995  * eval: (c-set-style "gnu")
 996  * End:
 997  */