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