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