src/vnet/sctp/sctp.h

   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 #ifndef included_vnet_sctp_h
  16 #define included_vnet_sctp_h
  17
  18 #include <vnet/vnet.h>
  19 #include <vnet/ip/ip.h>
  20 #include <vnet/sctp/sctp_timer.h>
  21 #include <vnet/sctp/sctp_packet.h>
  22 #include <vnet/session/transport.h>
  23 #include <vnet/session/session.h>
  24
  25 /* SCTP timers */
  26 #define foreach_sctp_timer                      \
  27   _(T1_INIT, "T1_INIT")                                 \
  28   _(T1_COOKIE, "T1_COOKIE")                             \
  29   _(T2_SHUTDOWN, "T2_SHUTDOWN")                 \
  30   _(T3_RXTX, "T3_RXTX")                                         \
  31   _(T4_HEARTBEAT, "T4_HB")                                      \
  32   _(T5_SHUTDOWN_GUARD, "T5_SHUTDOWN_GUARD")
  33
  34 typedef enum _sctp_timers
  35 {
  36 #define _(sym, str) SCTP_TIMER_##sym,
  37   foreach_sctp_timer
  38 #undef _
  39   SCTP_N_TIMERS
  40 } sctp_timers_e;
  41
  42 #define SCTP_TIMER_HANDLE_INVALID ((u32) ~0)
  43
  44 typedef enum _sctp_error
  45 {
  46 #define sctp_error(n,s) SCTP_ERROR_##n,
  47 #include <vnet/sctp/sctp_error.def>
  48 #undef sctp_error
  49   SCTP_N_ERROR,
  50 } sctp_error_t;
  51
  52 #define NO_FLAG 0
  53
  54 #define IS_T_BIT_SET(var) ((var) & (1))
  55 #define IS_E_BIT_SET(var) ((var) & (1))
  56 #define IS_B_BIT_SET(var) ((var) & (1<<1))
  57 #define IS_U_BIT_SET(var) ((var) & (1<<2))
  58
  59 #define MAX_SCTP_CONNECTIONS 32
  60 #define MAIN_SCTP_SUB_CONN_IDX 0
  61
  62 #if (VLIB_BUFFER_TRACE_TRAJECTORY)
  63 #define sctp_trajectory_add_start(b, start)                     \
  64 {                                                               \
  65     (*vlib_buffer_trace_trajectory_cb) (b, start);              \
  66 }
  67 #else
  68 #define sctp_trajectory_add_start(b, start)
  69 #endif
  70
  71 typedef struct _sctp_sub_connection
  72 {
  73   transport_connection_t connection;          /**< Common transport data. First! */
  74   void *parent;                                                         /**< Link to the parent-super connection */
  75
  76   u32 error_count; /**< The current error count for this destination. */
  77   u32 error_threshold; /**< Current error threshold for this destination,
  78                                 i.e. what value marks the destination down if error count reaches this value. */
  79   u32 cwnd; /**< The current congestion window. */
  80   u32 ssthresh; /**< The current ssthresh value. */
  81
  82   u32 RTO; /**< The current retransmission timeout value. */
  83   u32 SRTT; /**< The current smoothed round-trip time. */
  84   u32 RTTVAR; /**< The current RTT variation. */
  85
  86   u32 partially_acked_bytes; /**< The tracking method for increase of cwnd when in
  87                                   congestion avoidance mode (see Section 7.2.2).*/
  88
  89   u8 state; /**< The current state of this destination, i.e., DOWN, UP, ALLOW-HB, NO-HEARTBEAT, etc. */
  90
  91   u16 PMTU; /**< The current known path MTU. */
  92
  93   u32 timers[SCTP_N_TIMERS]; /**< A timer used by each destination. */
  94
  95   u8 RTO_pending; /**< A flag used to track if one of the DATA chunks sent to
  96                                   this address is currently being used to compute an RTT.
  97                                   If this flag is 0, the next DATA chunk sent to this destination
  98                                   should be used to compute an RTT and this flag should be set.
  99                                   Every time the RTT calculation completes (i.e., the DATA chunk is SACK'd),
 100                                   clear this flag. */
 101
 102   u32 last_time; /**< The time to which this destination was last sent a packet to.
 103                                   This can be used to determine if a HEARTBEAT is needed. */
 104
 105 } sctp_sub_connection_t;
 106
 107 typedef struct
 108 {
 109   u32 a_rwnd; /**< Maximum segment size advertised */
 110
 111 } sctp_options_t;
 112
 113 #define SetBit(A,k)     ( A[(k/32)] |= (1 << (k%32)) )
 114 #define ClearBit(A,k)   ( A[(k/32)] &= ~(1 << (k%32)) )
 115 #define TestBit(A,k)    ( A[(k/32)] & (1 << (k%32)) )
 116
 117 #define MAX_INFLIGHT_PACKETS    128
 118 #define MAX_ENQUEABLE_SACKS 2
 119
 120 /* This parameter indicates to the receiver how much increment in
 121  * milliseconds the sender wishes the receiver to add to its default
 122  * cookie life-span.
 123  */
 124 #define SUGGESTED_COOKIE_LIFE_SPAN_INCREMENT 1000
 125
 126 typedef struct _sctp_connection
 127 {
 128   sctp_sub_connection_t sub_conn[MAX_SCTP_CONNECTIONS]; /**< Common transport data. First! */
 129
 130   u8 state;                     /**< SCTP state as per sctp_state_t */
 131   u16 flags;            /**< Chunk flag (see sctp_chunks_common_hdr_t) */
 132
 133   u32 local_tag;        /**< INIT_TAG generated locally */
 134   u32 remote_tag;       /**< INIT_TAG generated by the remote peer */
 135
 136   u32 local_initial_tsn; /**< Initial TSN generated locally */
 137   u32 remote_initial_tsn; /**< Initial TSN generated by the remote-peer */
 138
 139   u32 peer_cookie_life_span_increment;
 140
 141   u32 overall_err_count; /**< The overall association error count. */
 142   u32 overall_err_treshold; /**< The threshold for this association that if the Overall Error Count
 143                                   reaches will cause this association to be torn down. */
 144
 145   u32 peer_rwnd; /**< Current calculated value of the peer's rwnd. */
 146
 147   u32 next_tsn; /**< The next TSN number to be assigned to a new DATA chunk.
 148                  This is sent in the INIT or INIT ACK chunk to the peer
 149                  and incremented each time a DATA chunk is assigned a
 150                  TSN (normally just prior to transmit or during
 151                  fragmentation). */
 152
 153   u32 next_tsn_expected; /**< The next TSN number expected to be received. */
 154
 155   u32 last_rcvd_tsn; /**< This is the last TSN received in sequence. This value
 156                          is set initially by taking the peer's initial TSN,
 157                  received in the INIT or INIT ACK chunk, and
 158                  subtracting one from it. */
 159
 160   u32 out_of_order_map[MAX_INFLIGHT_PACKETS]; /**< An array of bits or bytes indicating which out-of-order
 161                                 TSNs have been received (relative to the Last Rcvd TSN).
 162                                 If no gaps exist, i.e., no out-of-order packets have been received,
 163                                 this array will be set to all zero. */
 164
 165   u8 ack_state; /**< This flag indicates if the next received packet is set to be responded to with a SACK.
 166                                 This is initialized to 0. When a packet is received it is incremented.
 167                                 If this value reaches 2 or more, a SACK is sent and the value is reset to 0.
 168                                 Note: This is used only when no DATA chunks are received out-of-order.
 169                                 When DATA chunks are out-of-order, SACKs are not delayed (see Section 6). */
 170
 171   u32 a_rwnd; /** This value represents the dedicated buffer space, in number of bytes,
 172                                 the sender of the INIT has reserved in association with this window.
 173                                 During the life of the association, this buffer space SHOULD NOT be lessened
 174                                 (i.e., dedicated buffers taken away from this association);
 175                                 however, an endpoint MAY change the value of a_rwnd it sends in SACK chunks. */
 176
 177   u32 smallest_PMTU; /** The smallest PMTU discovered for all of the peer's transport addresses. */
 178
 179   u32 rcv_a_rwnd;               /**< LOCAL max seg size that includes options. To be updated by congestion algos, etc. */
 180   u32 snd_a_rwnd;               /**< REMOTE max seg size that includes options. To be updated if peer pushes back on window, etc.*/
 181
 182   u32 rtt_ts;
 183   u32 rtt_seq;
 184
 185   sctp_options_t rcv_opts;
 186   sctp_options_t snd_opts;
 187
 188   u32 snd_hdr_length;   /**< BASE HEADER LENGTH for the DATA chunk when sending */
 189   u8 next_avail_sub_conn; /**< Represent the index of the next free slot in sub_conn */
 190
 191 } sctp_connection_t;
 192
 193 typedef void (sctp_timer_expiration_handler) (u32 conn_index, u32 timer_id);
 194
 195 sctp_connection_t *sctp_connection_new (u8 thread_index);
 196 void sctp_sub_connection_add_ip4 (u8 thread_index,
 197                                   sctp_ipv4_addr_param_t * ipv4_addr);
 198 void sctp_sub_connection_add_ip6 (u8 thread_index,
 199                                   sctp_ipv6_addr_param_t * ipv6_addr);
 200 void sctp_connection_close (sctp_connection_t * tc);
 201 void sctp_connection_cleanup (sctp_connection_t * tc);
 202 void sctp_connection_del (sctp_connection_t * tc);
 203
 204 u32 sctp_push_header (transport_connection_t * tconn, vlib_buffer_t * b);
 205 void sctp_send_init (sctp_connection_t * tc);
 206 void sctp_send_shutdown (sctp_connection_t * tc);
 207 void sctp_send_shutdown_ack (sctp_connection_t * tc);
 208 void sctp_send_shutdown_complete (sctp_connection_t * tc);
 209 void sctp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index,
 210                                  u8 is_ip4);
 211 void sctp_flush_frames_to_output (u8 thread_index);
 212 void sctp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add);
 213
 214 format_function_t format_sctp_state;
 215
 216 u8 *format_sctp_connection_id (u8 * s, va_list * args);
 217 u8 *format_sctp_connection (u8 * s, va_list * args);
 218 u8 *format_sctp_scoreboard (u8 * s, va_list * args);
 219 u8 *format_sctp_header (u8 * s, va_list * args);
 220 u8 *format_sctp_tx_trace (u8 * s, va_list * args);
 221
 222 clib_error_t *sctp_init (vlib_main_t * vm);
 223 void sctp_connection_timers_init (sctp_connection_t * tc);
 224 void sctp_connection_timers_reset (sctp_connection_t * tc);
 225 void sctp_init_snd_vars (sctp_connection_t * tc);
 226 void sctp_init_mss (sctp_connection_t * tc);
 227
 228 void sctp_prepare_initack_chunk (sctp_connection_t * ts, vlib_buffer_t * b,
 229                                  ip4_address_t * ip4_addr,
 230                                  ip6_address_t * ip6_addr);
 231 void sctp_prepare_cookie_echo_chunk (sctp_connection_t * tc,
 232                                      vlib_buffer_t * b,
 233                                      sctp_state_cookie_param_t * sc);
 234 void sctp_prepare_cookie_ack_chunk (sctp_connection_t * tc,
 235                                     vlib_buffer_t * b);
 236 void sctp_prepare_sack_chunk (sctp_connection_t * tc, vlib_buffer_t * b);
 237
 238 u16 sctp_check_outstanding_data_chunks (sctp_connection_t * tc);
 239
 240 #define SCTP_TICK 0.001                 /**< SCTP tick period (s) */
 241 #define STHZ (u32) (1/SCTP_TICK)                /**< SCTP tick frequency */
 242 #define SCTP_TSTAMP_RESOLUTION SCTP_TICK        /**< Time stamp resolution */
 243 #define SCTP_PAWS_IDLE 24 * 24 * 60 * 60 * THZ /**< 24 days */
 244 #define SCTP_FIB_RECHECK_PERIOD 1 * THZ /**< Recheck every 1s */
 245 #define SCTP_MAX_OPTION_SPACE 40
 246
 247 #define SCTP_DUPACK_THRESHOLD   3
 248 #define SCTP_MAX_RX_FIFO_SIZE   4 << 20
 249 #define SCTP_MIN_RX_FIFO_SIZE   4 << 10
 250 #define SCTP_IW_N_SEGMENTS      10
 251 #define SCTP_ALWAYS_ACK         1       /**< On/off delayed acks */
 252 #define SCTP_USE_SACKS          1       /**< Disable only for testing */
 253
 254 #define IP_PROTOCOL_SCTP        132
 255
 256 /** SSCTP FSM state definitions as per RFC4960. */
 257 #define foreach_sctp_fsm_state                \
 258   _(CLOSED, "CLOSED")                         \
 259   _(COOKIE_WAIT, "COOKIE_WAIT")               \
 260   _(COOKIE_ECHOED, "COOKIE_ECHOED")           \
 261   _(ESTABLISHED, "ESTABLISHED")               \
 262   _(SHUTDOWN_PENDING, "SHUTDOWN_PENDING")     \
 263   _(SHUTDOWN_SENT, "SHUTDOWN_SENT")           \
 264   _(SHUTDOWN_RECEIVED, "SHUTDOWN_RECEIVED")   \
 265   _(SHUTDOWN_ACK_SENT, "SHUTDOWN_ACK_SENT")
 266
 267 typedef enum _sctp_state
 268 {
 269 #define _(sym, str) SCTP_STATE_##sym,
 270   foreach_sctp_fsm_state
 271 #undef _
 272   SCTP_N_STATES
 273 } sctp_state_t;
 274
 275 always_inline char *
 276 sctp_state_to_string (u8 state)
 277 {
 278   switch (state)
 279     {
 280     case SCTP_STATE_CLOSED:
 281       return "SCTP_STATE_CLOSED";
 282     case SCTP_STATE_COOKIE_WAIT:
 283       return "SCTP_STATE_COOKIE_WAIT";
 284     case SCTP_STATE_COOKIE_ECHOED:
 285       return "SCTP_STATE_COOKIE_ECHOED";
 286     case SCTP_STATE_ESTABLISHED:
 287       return "SCTP_STATE_ESTABLISHED";
 288     case SCTP_STATE_SHUTDOWN_PENDING:
 289       return "SCTP_STATE_SHUTDOWN_PENDING";
 290     case SCTP_STATE_SHUTDOWN_SENT:
 291       return "SCTP_STATE_SHUTDOWN_SENT";
 292     case SCTP_STATE_SHUTDOWN_RECEIVED:
 293       return "SCTP_STATE_SHUTDOWN_RECEIVED";
 294     case SCTP_STATE_SHUTDOWN_ACK_SENT:
 295       return "SCTP_STATE_SHUTDOWN_ACK_SENT";
 296     }
 297   return NULL;
 298 }
 299
 300 always_inline char *
 301 sctp_chunk_to_string (u8 type)
 302 {
 303   switch (type)
 304     {
 305     case DATA:
 306       return "DATA";
 307     case INIT:
 308       return "INIT";
 309     case INIT_ACK:
 310       return "INIT_ACK";
 311     case SACK:
 312       return "SACK";
 313     case HEARTBEAT:
 314       return "HEARTBEAT";
 315     case HEARTBEAT_ACK:
 316       return "HEARTBEAT_ACK";
 317     case ABORT:
 318       return "ABORT";
 319     case SHUTDOWN:
 320       return "SHUTDOWN";
 321     case SHUTDOWN_ACK:
 322       return "SHUTDOWN_ACK";
 323     case OPERATION_ERROR:
 324       return "OPERATION_ERROR";
 325     case COOKIE_ECHO:
 326       return "COOKIE_ECHO";
 327     case COOKIE_ACK:
 328       return "COOKIE_ACK";
 329     case ECNE:
 330       return "ECNE";
 331     case CWR:
 332       return "CWR";
 333     case SHUTDOWN_COMPLETE:
 334       return "SHUTDOWN_COMPLETE";
 335     }
 336   return NULL;
 337 }
 338
 339 always_inline char *
 340 sctp_optparam_type_to_string (u8 type)
 341 {
 342   switch (type)
 343     {
 344     case SCTP_IPV4_ADDRESS_TYPE:
 345       return "SCTP_IPV4_ADDRESS_TYPE";
 346     case SCTP_IPV6_ADDRESS_TYPE:
 347       return "SCTP_IPV6_ADDRESS_TYPE";
 348     case SCTP_STATE_COOKIE_TYPE:
 349       return "SCTP_STATE_COOKIE_TYPE";
 350     case SCTP_UNRECOGNIZED_TYPE:
 351       return "SCTP_UNRECOGNIZED_TYPE";
 352     case SCTP_COOKIE_PRESERVATIVE_TYPE:
 353       return "SCTP_COOKIE_PRESERVATIVE_TYPE";
 354     case SCTP_HOSTNAME_ADDRESS_TYPE:
 355       return "SCTP_HOSTNAME_ADDRESS_TYPE";
 356     case SCTP_SUPPORTED_ADDRESS_TYPES:
 357       return "SCTP_SUPPORTED_ADDRESS_TYPES";
 358     }
 359   return NULL;
 360 }
 361
 362 #define SCTP_TICK 0.001                 /**< SCTP tick period (s) */
 363 #define SHZ (u32) (1/SCTP_TICK)         /**< SCTP tick frequency */
 364
 365 /* As per RFC4960, page 83 */
 366 #define SCTP_RTO_INIT 3 * SHZ   /* 3 seconds */
 367 #define SCTP_RTO_MIN 1 * SHZ    /* 1 second */
 368 #define SCTP_RTO_MAX 60 * SHZ   /* 60 seconds */
 369 #define SCTP_RTO_BURST  4
 370 #define SCTP_RTO_ALPHA 1/8
 371 #define SCTP_RTO_BETA 1/4
 372 #define SCTP_VALID_COOKIE_LIFE 60 * SHZ /* 60 seconds */
 373 #define SCTP_ASSOCIATION_MAX_RETRANS 10
 374
 375 #define SCTP_TO_TIMER_TICK       SCTP_TICK*10   /* Period for converting from SCTP_TICK */
 376
 377 typedef struct _sctp_lookup_dispatch
 378 {
 379   u8 next, error;
 380 } sctp_lookup_dispatch_t;
 381
 382 typedef struct _sctp_main
 383 {
 384   /* Per-worker thread SCTP connection pools */
 385   sctp_connection_t **connections;
 386
 387   /* Pool of listeners. */
 388   sctp_connection_t *listener_pool;
 389
 390           /** Dispatch table by state and flags */
 391   sctp_lookup_dispatch_t dispatch_table[SCTP_N_STATES][64];
 392
 393   u8 log2_tstamp_clocks_per_tick;
 394   f64 tstamp_ticks_per_clock;
 395   u32 *time_now;
 396
 397           /** per-worker tx buffer free lists */
 398   u32 **tx_buffers;
 399           /** per-worker tx frames to SCTP 4/6 output nodes */
 400   vlib_frame_t **tx_frames[2];
 401           /** per-worker tx frames to ip 4/6 lookup nodes */
 402   vlib_frame_t **ip_lookup_tx_frames[2];
 403
 404   /* Per worker-thread timer wheel for connections timers */
 405   tw_timer_wheel_16t_2w_512sl_t *timer_wheels;
 406
 407   /* Pool of half-open connections on which we've sent a SYN */
 408   sctp_connection_t *half_open_connections;
 409   clib_spinlock_t half_open_lock;
 410
 411   /* TODO: Congestion control algorithms registered */
 412   /* sctp_cc_algorithm_t *cc_algos; */
 413
 414   /* Flag that indicates if stack is on or off */
 415   u8 is_enabled;
 416
 417           /** Number of preallocated connections */
 418   u32 preallocated_connections;
 419
 420           /** Transport table (preallocation) size parameters */
 421   u32 local_endpoints_table_memory;
 422   u32 local_endpoints_table_buckets;
 423
 424           /** Vectors of src addresses. Optional unless one needs > 63K active-opens */
 425   ip4_address_t *ip4_src_addresses;
 426   u32 last_v4_address_rotor;
 427   u32 last_v6_address_rotor;
 428   ip6_address_t *ip6_src_addresses;
 429
 430           /** vlib buffer size */
 431   u32 bytes_per_buffer;
 432
 433   u8 punt_unknown4;
 434   u8 punt_unknown6;
 435
 436 } sctp_main_t;
 437
 438 extern sctp_main_t sctp_main;
 439 extern vlib_node_registration_t sctp4_input_node;
 440 extern vlib_node_registration_t sctp6_input_node;
 441 extern vlib_node_registration_t sctp4_output_node;
 442 extern vlib_node_registration_t sctp6_output_node;
 443
 444 always_inline sctp_main_t *
 445 vnet_get_sctp_main ()
 446 {
 447   return &sctp_main;
 448 }
 449
 450 always_inline sctp_header_t *
 451 sctp_buffer_hdr (vlib_buffer_t * b)
 452 {
 453   ASSERT ((signed) b->current_data >= (signed) -VLIB_BUFFER_PRE_DATA_SIZE);
 454   return (sctp_header_t *) (b->data + b->current_data
 455                             + vnet_buffer (b)->sctp.hdr_offset);
 456 }
 457
 458 clib_error_t *vnet_sctp_enable_disable (vlib_main_t * vm, u8 is_en);
 459
 460 always_inline sctp_connection_t *
 461 sctp_half_open_connection_get (u32 conn_index)
 462 {
 463   sctp_connection_t *tc = 0;
 464   clib_spinlock_lock_if_init (&sctp_main.half_open_lock);
 465   if (!pool_is_free_index (sctp_main.half_open_connections, conn_index))
 466     tc = pool_elt_at_index (sctp_main.half_open_connections, conn_index);
 467   tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = tc;
 468   clib_spinlock_unlock_if_init (&sctp_main.half_open_lock);
 469   return tc;
 470 }
 471
 472 /**
 473  * Cleanup half-open connection
 474  *
 475  */
 476 always_inline void
 477 sctp_half_open_connection_del (sctp_connection_t * tc)
 478 {
 479   sctp_main_t *tm = vnet_get_sctp_main ();
 480   clib_spinlock_lock_if_init (&tm->half_open_lock);
 481   pool_put_index (tm->half_open_connections,
 482                   tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index);
 483   if (CLIB_DEBUG)
 484     memset (tc, 0xFA, sizeof (*tc));
 485   clib_spinlock_unlock_if_init (&tm->half_open_lock);
 486 }
 487
 488 always_inline u32
 489 sctp_set_time_now (u32 thread_index)
 490 {
 491   sctp_main.time_now[thread_index] = clib_cpu_time_now ()
 492     * sctp_main.tstamp_ticks_per_clock;
 493   return sctp_main.time_now[thread_index];
 494 }
 495
 496 always_inline void
 497 sctp_timer_set (sctp_connection_t * tc, u8 conn_idx, u8 timer_id,
 498                 u32 interval)
 499 {
 500   ASSERT (tc->sub_conn[conn_idx].connection.thread_index ==
 501           vlib_get_thread_index ());
 502   ASSERT (tc->sub_conn[conn_idx].timers[timer_id] ==
 503           SCTP_TIMER_HANDLE_INVALID);
 504
 505   sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
 506   tc->sub_conn[conn_idx].timers[timer_id] =
 507     tw_timer_start_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 508                                  sub->c_c_index, timer_id, interval);
 509 }
 510
 511 always_inline void
 512 sctp_timer_reset (sctp_connection_t * tc, u8 conn_idx, u8 timer_id)
 513 {
 514   ASSERT (tc->sub_conn[conn_idx].c_thread_index == vlib_get_thread_index ());
 515   if (tc->sub_conn[conn_idx].timers[timer_id] == SCTP_TIMER_HANDLE_INVALID)
 516     return;
 517
 518   sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
 519
 520   tw_timer_stop_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 521                               sub->timers[timer_id]);
 522   sub->timers[timer_id] = SCTP_TIMER_HANDLE_INVALID;
 523 }
 524
 525 always_inline void
 526 sctp_update_time (f64 now, u32 thread_index)
 527 {
 528   sctp_set_time_now (thread_index);
 529   tw_timer_expire_timers_16t_2w_512sl (&sctp_main.timer_wheels[thread_index],
 530                                        now);
 531   sctp_flush_frames_to_output (thread_index);
 532 }
 533
 534 /**
 535  * Try to cleanup half-open connection
 536  *
 537  * If called from a thread that doesn't own tc, the call won't have any
 538  * effect.
 539  *
 540  * @param tc - connection to be cleaned up
 541  * @return non-zero if cleanup failed.
 542  */
 543 always_inline int
 544 sctp_half_open_connection_cleanup (sctp_connection_t * tc)
 545 {
 546   /* Make sure this is the owning thread */
 547   if (tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_thread_index !=
 548       vlib_get_thread_index ())
 549     return 1;
 550   sctp_timer_reset (tc, MAIN_SCTP_SUB_CONN_IDX, SCTP_TIMER_T1_INIT);
 551   sctp_half_open_connection_del (tc);
 552   return 0;
 553 }
 554
 555 always_inline u32
 556 sctp_header_bytes ()
 557 {
 558   return sizeof (sctp_header_t);
 559 }
 560
 561 always_inline sctp_connection_t *
 562 sctp_get_connection_from_transport (transport_connection_t * tconn)
 563 {
 564   ASSERT (tconn != NULL);
 565
 566   sctp_sub_connection_t *sub = (sctp_sub_connection_t *) tconn;
 567 #if SCTP_ADV_DEBUG
 568   if (sub == NULL)
 569     SCTP_ADV_DBG ("sub == NULL");
 570   if (sub->parent == NULL)
 571     SCTP_ADV_DBG ("sub->parent == NULL");
 572 #endif
 573   return (sctp_connection_t *) sub->parent;
 574 }
 575
 576 always_inline u32
 577 sctp_time_now (void)
 578 {
 579   return sctp_main.time_now[vlib_get_thread_index ()];
 580 }
 581
 582 always_inline void
 583 sctp_timer_update (sctp_connection_t * tc, u8 conn_idx, u8 timer_id,
 584                    u32 interval)
 585 {
 586   ASSERT (tc->sub_conn[conn_idx].connection.thread_index ==
 587           vlib_get_thread_index ());
 588   sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
 589
 590   if (tc->sub_conn[conn_idx].timers[timer_id] != SCTP_TIMER_HANDLE_INVALID)
 591     tw_timer_stop_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 592                                 sub->timers[timer_id]);
 593
 594   tc->sub_conn[conn_idx].timers[timer_id] =
 595     tw_timer_start_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 596                                  sub->c_c_index, timer_id, interval);
 597 }
 598
 599 always_inline sctp_connection_t *
 600 sctp_listener_get (u32 tli)
 601 {
 602   return pool_elt_at_index (sctp_main.listener_pool, tli);
 603 }
 604
 605 #endif
 606
 607 always_inline sctp_connection_t *
 608 sctp_connection_get (u32 conn_index, u32 thread_index)
 609 {
 610   if (PREDICT_FALSE
 611       (pool_is_free_index (sctp_main.connections[thread_index], conn_index)))
 612     return 0;
 613   return pool_elt_at_index (sctp_main.connections[thread_index], conn_index);
 614 }
 615
 616 always_inline u8
 617 sctp_pick_conn_idx_on_chunk (sctp_chunk_type chunk_type)
 618 {
 619   u8 idx = MAIN_SCTP_SUB_CONN_IDX;
 620
 621   switch (chunk_type)
 622     {
 623     case DATA:
 624     case INIT:
 625     case INIT_ACK:
 626     case SACK:
 627     case HEARTBEAT:
 628     case HEARTBEAT_ACK:
 629     case ABORT:
 630     case SHUTDOWN:
 631     case SHUTDOWN_ACK:
 632     case OPERATION_ERROR:
 633     case COOKIE_ECHO:
 634     case COOKIE_ACK:
 635     case ECNE:
 636     case CWR:
 637     case SHUTDOWN_COMPLETE:
 638       idx = MAIN_SCTP_SUB_CONN_IDX;
 639     }
 640   return idx;
 641 }
 642
 643 always_inline u8
 644 sctp_pick_conn_idx_on_state (sctp_state_t state)
 645 {
 646   u8 idx = MAIN_SCTP_SUB_CONN_IDX;
 647
 648   switch (state)
 649     {
 650     case SCTP_STATE_CLOSED:
 651     case SCTP_STATE_COOKIE_WAIT:
 652     case SCTP_STATE_COOKIE_ECHOED:
 653     case SCTP_STATE_ESTABLISHED:
 654     case SCTP_STATE_SHUTDOWN_PENDING:
 655     case SCTP_STATE_SHUTDOWN_SENT:
 656     case SCTP_STATE_SHUTDOWN_RECEIVED:
 657     case SCTP_STATE_SHUTDOWN_ACK_SENT:
 658       idx = MAIN_SCTP_SUB_CONN_IDX;
 659     default:
 660       idx = MAIN_SCTP_SUB_CONN_IDX;
 661     }
 662   return idx;
 663 }
 664
 665 /**
 666  * Push SCTP header to buffer
 667  *
 668  * @param vm - vlib_main
 669  * @param b - buffer to write the header to
 670  * @param sp_net - source port net order
 671  * @param dp_net - destination port net order
 672  * @param sctp_hdr_opts_len - header and options length in bytes
 673  *
 674  * @return - pointer to start of SCTP header
 675  */
 676 always_inline void *
 677 vlib_buffer_push_sctp_net_order (vlib_buffer_t * b, u16 sp, u16 dp,
 678                                  u8 sctp_hdr_opts_len)
 679 {
 680   sctp_full_hdr_t *full_hdr;
 681
 682   full_hdr = vlib_buffer_push_uninit (b, sctp_hdr_opts_len);
 683
 684   full_hdr->hdr.src_port = sp;
 685   full_hdr->hdr.dst_port = dp;
 686   full_hdr->hdr.checksum = 0;
 687   return full_hdr;
 688 }
 689
 690 /**
 691  * Push SCTP header to buffer
 692  *
 693  * @param b - buffer to write the header to
 694  * @param sp_net - source port net order
 695  * @param dp_net - destination port net order
 696  * @param sctp_hdr_opts_len - header and options length in bytes
 697  *
 698  * @return - pointer to start of SCTP header
 699  */
 700 always_inline void *
 701 vlib_buffer_push_sctp (vlib_buffer_t * b, u16 sp_net, u16 dp_net,
 702                        u8 sctp_hdr_opts_len)
 703 {
 704   return vlib_buffer_push_sctp_net_order (b, sp_net, dp_net,
 705                                           sctp_hdr_opts_len);
 706 }
 707
 708 /*
 709  * fd.io coding-style-patch-verification: ON
 710  *
 711  * Local Variables:
 712  * eval: (c-set-style "gnu")
 713  * End:
 714  */