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                                   vlib_buffer_t * b0);
 256 void sctp_send_heartbeat (sctp_connection_t * sctp_conn);
 257 void sctp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index,
 258                                  u8 is_ip4);
 259 void sctp_flush_frames_to_output (u8 thread_index);
 260 void sctp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add);
 261
 262 format_function_t format_sctp_state;
 263
 264 u8 *format_sctp_connection_id (u8 * s, va_list * args);
 265 u8 *format_sctp_connection (u8 * s, va_list * args);
 266 u8 *format_sctp_scoreboard (u8 * s, va_list * args);
 267 u8 *format_sctp_header (u8 * s, va_list * args);
 268 u8 *format_sctp_tx_trace (u8 * s, va_list * args);
 269
 270 clib_error_t *sctp_init (vlib_main_t * vm);
 271 void sctp_connection_timers_init (sctp_connection_t * tc);
 272 void sctp_connection_timers_reset (sctp_connection_t * tc);
 273 void sctp_init_snd_vars (sctp_connection_t * tc);
 274 void sctp_init_mss (sctp_connection_t * tc);
 275
 276 void sctp_prepare_initack_chunk (sctp_connection_t * ts, vlib_buffer_t * b,
 277                                  ip4_address_t * ip4_addr,
 278                                  ip6_address_t * ip6_addr);
 279 void sctp_prepare_cookie_echo_chunk (sctp_connection_t * tc,
 280                                      vlib_buffer_t * b,
 281                                      sctp_state_cookie_param_t * sc);
 282 void sctp_prepare_cookie_ack_chunk (sctp_connection_t * tc,
 283                                     vlib_buffer_t * b);
 284 void sctp_prepare_sack_chunk (sctp_connection_t * tc, vlib_buffer_t * b);
 285 void sctp_prepare_heartbeat_ack_chunk (sctp_connection_t * sctp_conn,
 286                                        vlib_buffer_t * b);
 287
 288 u16 sctp_check_outstanding_data_chunks (sctp_connection_t * tc);
 289
 290 #define IP_PROTOCOL_SCTP        132
 291
 292 /** SSCTP FSM state definitions as per RFC4960. */
 293 #define foreach_sctp_fsm_state                \
 294   _(CLOSED, "CLOSED")                         \
 295   _(COOKIE_WAIT, "COOKIE_WAIT")               \
 296   _(COOKIE_ECHOED, "COOKIE_ECHOED")           \
 297   _(ESTABLISHED, "ESTABLISHED")               \
 298   _(SHUTDOWN_PENDING, "SHUTDOWN_PENDING")     \
 299   _(SHUTDOWN_SENT, "SHUTDOWN_SENT")           \
 300   _(SHUTDOWN_RECEIVED, "SHUTDOWN_RECEIVED")   \
 301   _(SHUTDOWN_ACK_SENT, "SHUTDOWN_ACK_SENT")
 302
 303 typedef enum _sctp_state
 304 {
 305 #define _(sym, str) SCTP_STATE_##sym,
 306   foreach_sctp_fsm_state
 307 #undef _
 308   SCTP_N_STATES
 309 } sctp_state_t;
 310
 311 always_inline char *
 312 sctp_state_to_string (u8 state)
 313 {
 314   switch (state)
 315     {
 316     case SCTP_STATE_CLOSED:
 317       return "SCTP_STATE_CLOSED";
 318     case SCTP_STATE_COOKIE_WAIT:
 319       return "SCTP_STATE_COOKIE_WAIT";
 320     case SCTP_STATE_COOKIE_ECHOED:
 321       return "SCTP_STATE_COOKIE_ECHOED";
 322     case SCTP_STATE_ESTABLISHED:
 323       return "SCTP_STATE_ESTABLISHED";
 324     case SCTP_STATE_SHUTDOWN_PENDING:
 325       return "SCTP_STATE_SHUTDOWN_PENDING";
 326     case SCTP_STATE_SHUTDOWN_SENT:
 327       return "SCTP_STATE_SHUTDOWN_SENT";
 328     case SCTP_STATE_SHUTDOWN_RECEIVED:
 329       return "SCTP_STATE_SHUTDOWN_RECEIVED";
 330     case SCTP_STATE_SHUTDOWN_ACK_SENT:
 331       return "SCTP_STATE_SHUTDOWN_ACK_SENT";
 332     }
 333   return NULL;
 334 }
 335
 336 always_inline char *
 337 sctp_chunk_to_string (u8 type)
 338 {
 339   switch (type)
 340     {
 341     case DATA:
 342       return "DATA";
 343     case INIT:
 344       return "INIT";
 345     case INIT_ACK:
 346       return "INIT_ACK";
 347     case SACK:
 348       return "SACK";
 349     case HEARTBEAT:
 350       return "HEARTBEAT";
 351     case HEARTBEAT_ACK:
 352       return "HEARTBEAT_ACK";
 353     case ABORT:
 354       return "ABORT";
 355     case SHUTDOWN:
 356       return "SHUTDOWN";
 357     case SHUTDOWN_ACK:
 358       return "SHUTDOWN_ACK";
 359     case OPERATION_ERROR:
 360       return "OPERATION_ERROR";
 361     case COOKIE_ECHO:
 362       return "COOKIE_ECHO";
 363     case COOKIE_ACK:
 364       return "COOKIE_ACK";
 365     case ECNE:
 366       return "ECNE";
 367     case CWR:
 368       return "CWR";
 369     case SHUTDOWN_COMPLETE:
 370       return "SHUTDOWN_COMPLETE";
 371     }
 372   return NULL;
 373 }
 374
 375 always_inline char *
 376 sctp_optparam_type_to_string (u8 type)
 377 {
 378   switch (type)
 379     {
 380     case SCTP_IPV4_ADDRESS_TYPE:
 381       return "SCTP_IPV4_ADDRESS_TYPE";
 382     case SCTP_IPV6_ADDRESS_TYPE:
 383       return "SCTP_IPV6_ADDRESS_TYPE";
 384     case SCTP_STATE_COOKIE_TYPE:
 385       return "SCTP_STATE_COOKIE_TYPE";
 386     case SCTP_UNRECOGNIZED_TYPE:
 387       return "SCTP_UNRECOGNIZED_TYPE";
 388     case SCTP_COOKIE_PRESERVATIVE_TYPE:
 389       return "SCTP_COOKIE_PRESERVATIVE_TYPE";
 390     case SCTP_HOSTNAME_ADDRESS_TYPE:
 391       return "SCTP_HOSTNAME_ADDRESS_TYPE";
 392     case SCTP_SUPPORTED_ADDRESS_TYPES:
 393       return "SCTP_SUPPORTED_ADDRESS_TYPES";
 394     }
 395   return NULL;
 396 }
 397
 398 #define SCTP_TICK 0.001                 /**< SCTP tick period (s) */
 399 #define SHZ (u32) (1/SCTP_TICK)         /**< SCTP tick frequency */
 400 #define SCTP_TSTAMP_RESOLUTION SCTP_TICK        /**< Time stamp resolution */
 401
 402 /* As per RFC4960, page 83 */
 403 #define SCTP_RTO_INIT 3 * SHZ   /* 3 seconds */
 404 #define SCTP_RTO_MIN 1 * SHZ    /* 1 second */
 405 #define SCTP_RTO_MAX 60 * SHZ   /* 60 seconds */
 406 #define SCTP_RTO_BURST  4
 407 #define SCTP_RTO_ALPHA 1/8
 408 #define SCTP_RTO_BETA 1/4
 409 #define SCTP_VALID_COOKIE_LIFE 60 * SHZ /* 60 seconds */
 410 #define SCTP_ASSOCIATION_MAX_RETRANS 10
 411
 412 #define SCTP_TO_TIMER_TICK       SCTP_TICK*10   /* Period for converting from SCTP_TICK */
 413
 414 typedef struct _sctp_lookup_dispatch
 415 {
 416   u8 next, error;
 417 } sctp_lookup_dispatch_t;
 418
 419 typedef struct _sctp_main
 420 {
 421   /* Per-worker thread SCTP connection pools */
 422   sctp_connection_t **connections;
 423
 424   /* Pool of listeners. */
 425   sctp_connection_t *listener_pool;
 426
 427           /** Dispatch table by state and flags */
 428   sctp_lookup_dispatch_t dispatch_table[SCTP_N_STATES][64];
 429
 430   u8 log2_tstamp_clocks_per_tick;
 431   f64 tstamp_ticks_per_clock;
 432   u32 *time_now;
 433
 434           /** per-worker tx buffer free lists */
 435   u32 **tx_buffers;
 436           /** per-worker tx frames to SCTP 4/6 output nodes */
 437   vlib_frame_t **tx_frames[2];
 438           /** per-worker tx frames to ip 4/6 lookup nodes */
 439   vlib_frame_t **ip_lookup_tx_frames[2];
 440
 441   /* Per worker-thread timer wheel for connections timers */
 442   tw_timer_wheel_16t_2w_512sl_t *timer_wheels;
 443
 444   /* Pool of half-open connections on which we've sent a SYN */
 445   sctp_connection_t *half_open_connections;
 446   clib_spinlock_t half_open_lock;
 447
 448   /* TODO: Congestion control algorithms registered */
 449   /* sctp_cc_algorithm_t *cc_algos; */
 450
 451   /* Flag that indicates if stack is on or off */
 452   u8 is_enabled;
 453
 454           /** Number of preallocated connections */
 455   u32 preallocated_connections;
 456
 457           /** Transport table (preallocation) size parameters */
 458   u32 local_endpoints_table_memory;
 459   u32 local_endpoints_table_buckets;
 460
 461           /** Vectors of src addresses. Optional unless one needs > 63K active-opens */
 462   ip4_address_t *ip4_src_addresses;
 463   u32 last_v4_address_rotor;
 464   u32 last_v6_address_rotor;
 465   ip6_address_t *ip6_src_addresses;
 466
 467           /** vlib buffer size */
 468   u32 bytes_per_buffer;
 469
 470   u8 punt_unknown4;
 471   u8 punt_unknown6;
 472
 473 } sctp_main_t;
 474
 475 extern sctp_main_t sctp_main;
 476 extern vlib_node_registration_t sctp4_input_node;
 477 extern vlib_node_registration_t sctp6_input_node;
 478 extern vlib_node_registration_t sctp4_output_node;
 479 extern vlib_node_registration_t sctp6_output_node;
 480
 481 always_inline sctp_main_t *
 482 vnet_get_sctp_main ()
 483 {
 484   return &sctp_main;
 485 }
 486
 487 always_inline sctp_header_t *
 488 sctp_buffer_hdr (vlib_buffer_t * b)
 489 {
 490   ASSERT ((signed) b->current_data >= (signed) -VLIB_BUFFER_PRE_DATA_SIZE);
 491   return (sctp_header_t *) (b->data + b->current_data
 492                             + vnet_buffer (b)->sctp.hdr_offset);
 493 }
 494
 495 clib_error_t *vnet_sctp_enable_disable (vlib_main_t * vm, u8 is_en);
 496
 497 always_inline sctp_connection_t *
 498 sctp_half_open_connection_get (u32 conn_index)
 499 {
 500   sctp_connection_t *tc = 0;
 501   clib_spinlock_lock_if_init (&sctp_main.half_open_lock);
 502   if (!pool_is_free_index (sctp_main.half_open_connections, conn_index))
 503     tc = pool_elt_at_index (sctp_main.half_open_connections, conn_index);
 504   tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = tc;
 505   clib_spinlock_unlock_if_init (&sctp_main.half_open_lock);
 506   return tc;
 507 }
 508
 509 /**
 510  * Cleanup half-open connection
 511  *
 512  */
 513 always_inline void
 514 sctp_half_open_connection_del (sctp_connection_t * tc)
 515 {
 516   sctp_main_t *tm = vnet_get_sctp_main ();
 517   clib_spinlock_lock_if_init (&tm->half_open_lock);
 518   pool_put_index (tm->half_open_connections,
 519                   tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index);
 520   if (CLIB_DEBUG)
 521     memset (tc, 0xFA, sizeof (*tc));
 522   clib_spinlock_unlock_if_init (&tm->half_open_lock);
 523 }
 524
 525 always_inline u32
 526 sctp_set_time_now (u32 thread_index)
 527 {
 528   sctp_main.time_now[thread_index] = clib_cpu_time_now ()
 529     * sctp_main.tstamp_ticks_per_clock;
 530   return sctp_main.time_now[thread_index];
 531 }
 532
 533 always_inline void
 534 sctp_timer_set (sctp_connection_t * tc, u8 conn_idx, u8 timer_id,
 535                 u32 interval)
 536 {
 537   ASSERT (tc->sub_conn[conn_idx].connection.thread_index ==
 538           vlib_get_thread_index ());
 539   ASSERT (tc->sub_conn[conn_idx].timers[timer_id] ==
 540           SCTP_TIMER_HANDLE_INVALID);
 541
 542   sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
 543   sub->timers[timer_id] =
 544     tw_timer_start_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 545                                  sub->c_c_index, timer_id, interval);
 546 }
 547
 548 always_inline void
 549 sctp_timer_reset (sctp_connection_t * tc, u8 conn_idx, u8 timer_id)
 550 {
 551   ASSERT (tc->sub_conn[conn_idx].c_thread_index == vlib_get_thread_index ());
 552   if (tc->sub_conn[conn_idx].timers[timer_id] == SCTP_TIMER_HANDLE_INVALID)
 553     return;
 554
 555   sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
 556
 557   tw_timer_stop_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 558                               sub->timers[timer_id]);
 559   sub->timers[timer_id] = SCTP_TIMER_HANDLE_INVALID;
 560 }
 561
 562 /**
 563  * Try to cleanup half-open connection
 564  *
 565  * If called from a thread that doesn't own tc, the call won't have any
 566  * effect.
 567  *
 568  * @param tc - connection to be cleaned up
 569  * @return non-zero if cleanup failed.
 570  */
 571 always_inline int
 572 sctp_half_open_connection_cleanup (sctp_connection_t * tc)
 573 {
 574   /* Make sure this is the owning thread */
 575   if (tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_thread_index !=
 576       vlib_get_thread_index ())
 577     return 1;
 578   sctp_timer_reset (tc, MAIN_SCTP_SUB_CONN_IDX, SCTP_TIMER_T1_INIT);
 579   sctp_half_open_connection_del (tc);
 580   return 0;
 581 }
 582
 583 always_inline u32
 584 sctp_header_bytes ()
 585 {
 586   return sizeof (sctp_header_t);
 587 }
 588
 589 always_inline sctp_connection_t *
 590 sctp_get_connection_from_transport (transport_connection_t * tconn)
 591 {
 592   ASSERT (tconn != NULL);
 593
 594   sctp_sub_connection_t *sub = (sctp_sub_connection_t *) tconn;
 595 #if SCTP_ADV_DEBUG
 596   if (sub == NULL)
 597     SCTP_ADV_DBG ("sub == NULL");
 598   if (sub->parent == NULL)
 599     SCTP_ADV_DBG ("sub->parent == NULL");
 600 #endif
 601   return (sctp_connection_t *) sub->parent;
 602 }
 603
 604 always_inline u32
 605 sctp_time_now (void)
 606 {
 607   return sctp_main.time_now[vlib_get_thread_index ()];
 608 }
 609
 610 #define ABS(x) ((x) > 0) ? (x) : -(x);
 611
 612 always_inline void
 613 sctp_calculate_rto (sctp_connection_t * sctp_conn, u8 conn_idx)
 614 {
 615   /* See RFC4960, 6.3.1.  RTO Calculation */
 616   u32 RTO = 0;
 617   f32 RTTVAR = 0;
 618   u32 now = sctp_time_now ();
 619   u32 prev_ts = sctp_conn->sub_conn[conn_idx].rtt_ts;
 620   u32 R = prev_ts - now;
 621
 622   if (sctp_conn->sub_conn[conn_idx].RTO == 0)   // C1: Let's initialize our RTO
 623     {
 624       sctp_conn->sub_conn[conn_idx].RTO = SCTP_RTO_MIN;
 625       return;
 626     }
 627
 628   if (sctp_conn->sub_conn[conn_idx].RTO == SCTP_RTO_MIN && sctp_conn->sub_conn[conn_idx].SRTT == 0)     // C2: First RTT calculation
 629     {
 630       sctp_conn->sub_conn[conn_idx].SRTT = R;
 631       RTTVAR = R / 2;
 632
 633       if (RTTVAR == 0)
 634         RTTVAR = 100e-3;        /* 100 ms */
 635
 636       sctp_conn->sub_conn[conn_idx].RTTVAR = RTTVAR;
 637     }
 638   else                          // C3: RTT already exists; let's recalculate
 639     {
 640       RTTVAR = (1 - SCTP_RTO_BETA) * sctp_conn->sub_conn[conn_idx].RTTVAR +
 641         SCTP_RTO_BETA * ABS (sctp_conn->sub_conn[conn_idx].SRTT - R);
 642
 643       if (RTTVAR == 0)
 644         RTTVAR = 100e-3;        /* 100 ms */
 645
 646       sctp_conn->sub_conn[conn_idx].RTTVAR = RTTVAR;
 647
 648       sctp_conn->sub_conn[conn_idx].SRTT =
 649         (1 - SCTP_RTO_ALPHA) * sctp_conn->sub_conn[conn_idx].SRTT +
 650         SCTP_RTO_ALPHA * R;
 651     }
 652
 653   RTO =
 654     sctp_conn->sub_conn[conn_idx].SRTT +
 655     4 * sctp_conn->sub_conn[conn_idx].RTTVAR;
 656   if (RTO < SCTP_RTO_MIN)       // C6
 657     RTO = SCTP_RTO_MIN;
 658
 659   if (RTO > SCTP_RTO_MAX)       // C7
 660     RTO = SCTP_RTO_MAX;
 661
 662   sctp_conn->sub_conn[conn_idx].RTO = RTO;
 663 }
 664
 665 always_inline void
 666 sctp_timer_update (sctp_connection_t * tc, u8 conn_idx, u8 timer_id,
 667                    u32 interval)
 668 {
 669   ASSERT (tc->sub_conn[conn_idx].connection.thread_index ==
 670           vlib_get_thread_index ());
 671   sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
 672
 673   if (tc->sub_conn[conn_idx].timers[timer_id] != SCTP_TIMER_HANDLE_INVALID)
 674     tw_timer_stop_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 675                                 sub->timers[timer_id]);
 676
 677   tc->sub_conn[conn_idx].timers[timer_id] =
 678     tw_timer_start_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 679                                  sub->c_c_index, timer_id, interval);
 680 }
 681
 682 always_inline sctp_connection_t *
 683 sctp_listener_get (u32 tli)
 684 {
 685   return pool_elt_at_index (sctp_main.listener_pool, tli);
 686 }
 687
 688 #endif
 689
 690 always_inline sctp_connection_t *
 691 sctp_connection_get (u32 conn_index, u32 thread_index)
 692 {
 693   if (PREDICT_FALSE
 694       (pool_is_free_index (sctp_main.connections[thread_index], conn_index)))
 695     return 0;
 696   return pool_elt_at_index (sctp_main.connections[thread_index], conn_index);
 697 }
 698
 699 always_inline u8
 700 sctp_pick_conn_idx_on_chunk (sctp_chunk_type chunk_type)
 701 {
 702   u8 idx = MAIN_SCTP_SUB_CONN_IDX;
 703
 704   switch (chunk_type)
 705     {
 706     case DATA:
 707     case INIT:
 708     case INIT_ACK:
 709     case SACK:
 710     case HEARTBEAT:
 711     case HEARTBEAT_ACK:
 712     case ABORT:
 713     case SHUTDOWN:
 714     case SHUTDOWN_ACK:
 715     case OPERATION_ERROR:
 716     case COOKIE_ECHO:
 717     case COOKIE_ACK:
 718     case ECNE:
 719     case CWR:
 720     case SHUTDOWN_COMPLETE:
 721       idx = MAIN_SCTP_SUB_CONN_IDX;
 722       break;
 723     default:
 724       idx = 0;
 725     }
 726   return idx;
 727 }
 728
 729 always_inline u8
 730 sctp_pick_conn_idx_on_state (sctp_state_t state)
 731 {
 732   u8 idx = MAIN_SCTP_SUB_CONN_IDX;
 733
 734   switch (state)
 735     {
 736     case SCTP_STATE_CLOSED:
 737     case SCTP_STATE_COOKIE_WAIT:
 738     case SCTP_STATE_COOKIE_ECHOED:
 739     case SCTP_STATE_ESTABLISHED:
 740     case SCTP_STATE_SHUTDOWN_PENDING:
 741     case SCTP_STATE_SHUTDOWN_SENT:
 742     case SCTP_STATE_SHUTDOWN_RECEIVED:
 743     case SCTP_STATE_SHUTDOWN_ACK_SENT:
 744       idx = MAIN_SCTP_SUB_CONN_IDX;
 745     default:
 746       idx = MAIN_SCTP_SUB_CONN_IDX;
 747     }
 748   return idx;
 749 }
 750
 751 /**
 752  * Push SCTP header to buffer
 753  *
 754  * @param vm - vlib_main
 755  * @param b - buffer to write the header to
 756  * @param sp_net - source port net order
 757  * @param dp_net - destination port net order
 758  * @param sctp_hdr_opts_len - header and options length in bytes
 759  *
 760  * @return - pointer to start of SCTP header
 761  */
 762 always_inline void *
 763 vlib_buffer_push_sctp_net_order (vlib_buffer_t * b, u16 sp, u16 dp,
 764                                  u8 sctp_hdr_opts_len)
 765 {
 766   sctp_full_hdr_t *full_hdr;
 767
 768   full_hdr = vlib_buffer_push_uninit (b, sctp_hdr_opts_len);
 769
 770   full_hdr->hdr.src_port = sp;
 771   full_hdr->hdr.dst_port = dp;
 772   full_hdr->hdr.checksum = 0;
 773   return full_hdr;
 774 }
 775
 776 /**
 777  * Push SCTP header to buffer
 778  *
 779  * @param b - buffer to write the header to
 780  * @param sp_net - source port net order
 781  * @param dp_net - destination port net order
 782  * @param sctp_hdr_opts_len - header and options length in bytes
 783  *
 784  * @return - pointer to start of SCTP header
 785  */
 786 always_inline void *
 787 vlib_buffer_push_sctp (vlib_buffer_t * b, u16 sp_net, u16 dp_net,
 788                        u8 sctp_hdr_opts_len)
 789 {
 790   return vlib_buffer_push_sctp_net_order (b, sp_net, dp_net,
 791                                           sctp_hdr_opts_len);
 792 }
 793
 794 /*
 795  * fd.io coding-style-patch-verification: ON
 796  *
 797  * Local Variables:
 798  * eval: (c-set-style "gnu")
 799  * End:
 800  */