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 8
  81 #define SCTP_PRIMARY_PATH_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 enum _sctp_subconn_state
  93 {
  94   SCTP_SUBCONN_STATE_DOWN = 0,
  95   SCTP_SUBCONN_STATE_UP,
  96   SCTP_SUBCONN_STATE_ALLOW_HB
  97 };
  98
  99 #define SCTP_INITIAL_SSHTRESH 65535
 100 typedef struct _sctp_sub_connection
 101 {
 102   transport_connection_t connection;          /**< Common transport data. First! */
 103
 104   u8 subconn_idx; /**< This indicates the position of this sub-connection in the super-set container of connections pool */
 105   u32 error_count; /**< The current error count for this destination. */
 106   u32 error_threshold; /**< Current error threshold for this destination,
 107                                 i.e. what value marks the destination down if error count reaches this value. */
 108   u32 cwnd; /**< Congestion control window (cwnd, in bytes), which is adjusted by
 109       the sender based on observed network conditions. */
 110   u32 ssthresh; /**< Slow-start threshold (in bytes), which is used by the
 111       sender to distinguish slow-start and congestion avoidance phases. */
 112
 113   u32 rtt_ts;   /**< USED to hold the timestamp of when the packet has been sent */
 114
 115   u32 RTO; /**< The current retransmission timeout value. */
 116   u32 SRTT; /**< The current smoothed round-trip time. */
 117   f32 RTTVAR; /**< The current RTT variation. */
 118
 119   u32 partially_acked_bytes; /**< The tracking method for increase of cwnd when in
 120                                   congestion avoidance mode (see Section 7.2.2).*/
 121
 122   u8 state; /**< The current state of this destination, i.e., DOWN, UP, ALLOW-HB, NO-HEARTBEAT, etc. */
 123
 124   u16 PMTU; /**< The current known path MTU. */
 125
 126   u32 timers[SCTP_N_TIMERS]; /**< A timer used by each destination. */
 127
 128   u8 RTO_pending; /**< A flag used to track if one of the DATA chunks sent to
 129                                   this address is currently being used to compute an RTT.
 130                                   If this flag is 0, the next DATA chunk sent to this destination
 131                                   should be used to compute an RTT and this flag should be set.
 132                                   Every time the RTT calculation completes (i.e., the DATA chunk is SACK'd),
 133                                   clear this flag. */
 134
 135   u32 last_seen; /**< The time to which this destination was last sent a packet to.
 136                                   This can be used to determine if a HEARTBEAT is needed. */
 137
 138   u32 last_data_ts; /**< Used to hold the timestamp value of last time we sent a DATA chunk */
 139
 140   u8 unacknowledged_hb; /**< Used to track how many unacknowledged heartbeats we had;
 141                                   If more than SCTP_PATH_MAX_RETRANS then connection is considered unreachable. */
 142
 143   u8 is_retransmitting; /**< A flag (0 = no, 1 = yes) indicating whether the connection is retransmitting a previous packet */
 144
 145   u8 enqueue_state; /**< if set to 1 indicates that DATA is still being handled hence cannot shutdown this connection yet */
 146
 147 } sctp_sub_connection_t;
 148
 149 typedef struct
 150 {
 151   u32 a_rwnd; /**< Maximum segment size advertised */
 152
 153 } sctp_options_t;
 154
 155 /* Useful macros to deal with the out_of_order_map (array of bit) */
 156 #define SET_BIT(A,k)     ( A[(k/32)] |= (1 << (k%32)) )
 157 #define CLEAR_BIT(A,k)   ( A[(k/32)] &= ~(1 << (k%32)) )
 158 #define TEST_BIT(A,k)    ( A[(k/32)] & (1 << (k%32)) )
 159
 160 always_inline void
 161 _bytes_swap (void *pv, size_t n)
 162 {
 163   char *p = pv;
 164   size_t lo, hi;
 165   for (lo = 0, hi = n - 1; hi > lo; lo++, hi--)
 166     {
 167       char tmp = p[lo];
 168       p[lo] = p[hi];
 169       p[hi] = tmp;
 170     }
 171 }
 172
 173 #define ENDIANESS_SWAP(x) _bytes_swap(&x, sizeof(x));
 174
 175 #define MAX_INFLIGHT_PACKETS    128
 176 #define MAX_ENQUEABLE_SACKS 2
 177
 178 /* This parameter indicates to the receiver how much increment in
 179  * milliseconds the sender wishes the receiver to add to its default
 180  * cookie life-span.
 181  */
 182 #define SUGGESTED_COOKIE_LIFE_SPAN_INCREMENT 1000
 183
 184 typedef struct _sctp_user_configuration
 185 {
 186   u8 never_delay_sack;
 187   u8 never_bundle;
 188
 189 } sctp_user_configuration_t;
 190
 191 typedef struct _sctp_connection
 192 {
 193   sctp_sub_connection_t sub_conn[MAX_SCTP_CONNECTIONS]; /**< Common transport data. First! */
 194   sctp_user_configuration_t conn_config; /**< Allows tuning of some SCTP behaviors */
 195
 196   u8 state;                     /**< SCTP state as per sctp_state_t */
 197   u16 flags;            /**< Chunk flag (see sctp_chunks_common_hdr_t) */
 198
 199   u32 local_tag;        /**< INIT_TAG generated locally */
 200   u32 remote_tag;       /**< INIT_TAG generated by the remote peer */
 201
 202   u32 local_initial_tsn; /**< Initial TSN generated locally */
 203   u32 remote_initial_tsn; /**< Initial TSN generated by the remote-peer */
 204
 205   u32 peer_cookie_life_span_increment;
 206
 207   u32 overall_err_count; /**< The overall association error count. */
 208   u32 overall_err_treshold; /**< The threshold for this association that if the Overall Error Count
 209                                   reaches will cause this association to be torn down. */
 210
 211   u8 init_retransmit_err; /**< Error counter for the INIT transmission phase */
 212
 213   u32 peer_rwnd; /**< Current calculated value of the peer's rwnd. */
 214
 215   u32 next_tsn; /**< The next TSN number to be assigned to a new DATA chunk.
 216                  This is sent in the INIT or INIT ACK chunk to the peer
 217                  and incremented each time a DATA chunk is assigned a
 218                  TSN (normally just prior to transmit or during
 219                  fragmentation). */
 220
 221   u32 last_unacked_tsn; /** < Last TSN number still unacked */
 222   u32 next_tsn_expected; /**< The next TSN number expected to be received. */
 223
 224   u32 last_rcvd_tsn; /**< This is the last TSN received in sequence. This value
 225                          is set initially by taking the peer's initial TSN,
 226                  received in the INIT or INIT ACK chunk, and
 227                  subtracting one from it. */
 228
 229   u32 out_of_order_map[MAX_INFLIGHT_PACKETS]; /**< An array of bits or bytes indicating which out-of-order
 230                                 TSNs have been received (relative to the Last Rcvd TSN).
 231                                 If no gaps exist, i.e., no out-of-order packets have been received,
 232                                 this array will be set to all zero. */
 233
 234   u8 ack_state; /**< This flag indicates if the next received packet is set to be responded to with a SACK.
 235                                 This is initialized to 0. When a packet is received it is incremented.
 236                                 If this value reaches 2 or more, a SACK is sent and the value is reset to 0.
 237                                 Note: This is used only when no DATA chunks are received out-of-order.
 238                                 When DATA chunks are out-of-order, SACKs are not delayed (see Section 6). */
 239
 240   u8 smallest_PMTU_idx; /** The index of the sub-connection with the smallest PMTU discovered across all peer's transport addresses. */
 241
 242   u8 overall_sending_status; /**< 0 indicates first fragment of a user message
 243                                                                   1 indicates normal stream
 244                                                                   2 indicates last fragment of a user message */
 245
 246   u8 forming_association_changed; /**< This is a flag indicating whether the original association has been modified during
 247                                   the life-span of the association itself. For instance, a new sub-connection might have been added. */
 248
 249   sctp_state_cookie_param_t cookie_param; /**< Temporary location to save cookie information; it can be used to
 250                                   when timeout expires and sending again a COOKIE is require. */
 251
 252 } sctp_connection_t;
 253
 254 typedef void (sctp_timer_expiration_handler) (u32 conn_index, u32 timer_id);
 255
 256 sctp_connection_t *sctp_connection_new (u8 thread_index);
 257
 258 u8
 259 sctp_sub_connection_add_ip4 (vlib_main_t * vm,
 260                              ip4_address_t * lcl_addr,
 261                              ip4_address_t * rmt_addr);
 262
 263 u8
 264 sctp_sub_connection_add_ip6 (vlib_main_t * vm,
 265                              ip6_address_t * lcl_addr,
 266                              ip6_address_t * rmt_addr);
 267
 268 u8
 269 sctp_sub_connection_del_ip4 (ip4_address_t * lcl_addr,
 270                              ip4_address_t * rmt_addr);
 271
 272 u8
 273 sctp_sub_connection_del_ip6 (ip6_address_t * lcl_addr,
 274                              ip6_address_t * rmt_addr);
 275
 276 u8 sctp_configure (sctp_user_configuration_t config);
 277
 278 void sctp_connection_close (sctp_connection_t * sctp_conn);
 279 void sctp_connection_cleanup (sctp_connection_t * sctp_conn);
 280 void sctp_connection_del (sctp_connection_t * sctp_conn);
 281
 282 u32 sctp_push_header (transport_connection_t * tconn, vlib_buffer_t * b);
 283 void sctp_send_init (sctp_connection_t * sctp_conn);
 284 void sctp_send_cookie_echo (sctp_connection_t * sctp_conn);
 285 void sctp_send_shutdown (sctp_connection_t * sctp_conn);
 286 void sctp_send_shutdown_ack (sctp_connection_t * sctp_conn, u8 idx,
 287                              vlib_buffer_t * b);
 288 void sctp_send_shutdown_complete (sctp_connection_t * sctp_conn, u8 idx,
 289                                   vlib_buffer_t * b0);
 290 void sctp_send_heartbeat (sctp_connection_t * sctp_conn);
 291 void sctp_data_retransmit (sctp_connection_t * sctp_conn);
 292 void sctp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index,
 293                                  u8 is_ip4);
 294 void sctp_flush_frames_to_output (u8 thread_index);
 295 void sctp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add);
 296
 297 format_function_t format_sctp_state;
 298
 299 u8 *format_sctp_connection_id (u8 * s, va_list * args);
 300 u8 *format_sctp_connection (u8 * s, va_list * args);
 301 u8 *format_sctp_scoreboard (u8 * s, va_list * args);
 302 u8 *format_sctp_header (u8 * s, va_list * args);
 303 u8 *format_sctp_tx_trace (u8 * s, va_list * args);
 304
 305 clib_error_t *sctp_init (vlib_main_t * vm);
 306 void sctp_connection_timers_init (sctp_connection_t * sctp_conn);
 307 void sctp_connection_timers_reset (sctp_connection_t * sctp_conn);
 308 void sctp_init_snd_vars (sctp_connection_t * sctp_conn);
 309 void sctp_init_mss (sctp_connection_t * sctp_conn);
 310
 311 void sctp_prepare_initack_chunk (sctp_connection_t * sctp_conn, u8 idx,
 312                                  vlib_buffer_t * b, ip4_address_t * ip4_addr,
 313                                  ip6_address_t * ip6_addr);
 314 void
 315 sctp_prepare_initack_chunk_for_collision (sctp_connection_t * sctp_conn,
 316                                           u8 idx, vlib_buffer_t * b,
 317                                           ip4_address_t * ip4_addr,
 318                                           ip6_address_t * ip6_addr);
 319 void sctp_prepare_abort_for_collision (sctp_connection_t * sctp_conn, u8 idx,
 320                                        vlib_buffer_t * b,
 321                                        ip4_address_t * ip4_addr,
 322                                        ip6_address_t * ip6_addr);
 323 void
 324 sctp_prepare_operation_error (sctp_connection_t * sctp_conn, u8 idx,
 325                               vlib_buffer_t * b, u8 err_cause);
 326 void sctp_prepare_cookie_echo_chunk (sctp_connection_t * sctp_conn, u8 idx,
 327                                      vlib_buffer_t * b, u8 reuse_buffer);
 328 void sctp_prepare_cookie_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
 329                                     vlib_buffer_t * b);
 330 void sctp_prepare_sack_chunk (sctp_connection_t * sctp_conn, u8 idx,
 331                               vlib_buffer_t * b);
 332 void sctp_prepare_heartbeat_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
 333                                        vlib_buffer_t * b);
 334
 335 u16 sctp_check_outstanding_data_chunks (sctp_connection_t * sctp_conn);
 336
 337 void sctp_api_reference (void);
 338
 339 #define IP_PROTOCOL_SCTP        132
 340
 341 /** SSCTP FSM state definitions as per RFC4960. */
 342 #define foreach_sctp_fsm_state                \
 343   _(CLOSED, "CLOSED")                         \
 344   _(COOKIE_WAIT, "COOKIE_WAIT")               \
 345   _(COOKIE_ECHOED, "COOKIE_ECHOED")           \
 346   _(ESTABLISHED, "ESTABLISHED")               \
 347   _(SHUTDOWN_PENDING, "SHUTDOWN_PENDING")     \
 348   _(SHUTDOWN_SENT, "SHUTDOWN_SENT")           \
 349   _(SHUTDOWN_RECEIVED, "SHUTDOWN_RECEIVED")   \
 350   _(SHUTDOWN_ACK_SENT, "SHUTDOWN_ACK_SENT")
 351
 352 typedef enum _sctp_state
 353 {
 354 #define _(sym, str) SCTP_STATE_##sym,
 355   foreach_sctp_fsm_state
 356 #undef _
 357   SCTP_N_STATES
 358 } sctp_state_t;
 359
 360 always_inline char *
 361 sctp_state_to_string (u8 state)
 362 {
 363   switch (state)
 364     {
 365     case SCTP_STATE_CLOSED:
 366       return "SCTP_STATE_CLOSED";
 367     case SCTP_STATE_COOKIE_WAIT:
 368       return "SCTP_STATE_COOKIE_WAIT";
 369     case SCTP_STATE_COOKIE_ECHOED:
 370       return "SCTP_STATE_COOKIE_ECHOED";
 371     case SCTP_STATE_ESTABLISHED:
 372       return "SCTP_STATE_ESTABLISHED";
 373     case SCTP_STATE_SHUTDOWN_PENDING:
 374       return "SCTP_STATE_SHUTDOWN_PENDING";
 375     case SCTP_STATE_SHUTDOWN_SENT:
 376       return "SCTP_STATE_SHUTDOWN_SENT";
 377     case SCTP_STATE_SHUTDOWN_RECEIVED:
 378       return "SCTP_STATE_SHUTDOWN_RECEIVED";
 379     case SCTP_STATE_SHUTDOWN_ACK_SENT:
 380       return "SCTP_STATE_SHUTDOWN_ACK_SENT";
 381     }
 382   return NULL;
 383 }
 384
 385 always_inline char *
 386 sctp_chunk_to_string (u8 type)
 387 {
 388   switch (type)
 389     {
 390     case DATA:
 391       return "DATA";
 392     case INIT:
 393       return "INIT";
 394     case INIT_ACK:
 395       return "INIT_ACK";
 396     case SACK:
 397       return "SACK";
 398     case HEARTBEAT:
 399       return "HEARTBEAT";
 400     case HEARTBEAT_ACK:
 401       return "HEARTBEAT_ACK";
 402     case ABORT:
 403       return "ABORT";
 404     case SHUTDOWN:
 405       return "SHUTDOWN";
 406     case SHUTDOWN_ACK:
 407       return "SHUTDOWN_ACK";
 408     case OPERATION_ERROR:
 409       return "OPERATION_ERROR";
 410     case COOKIE_ECHO:
 411       return "COOKIE_ECHO";
 412     case COOKIE_ACK:
 413       return "COOKIE_ACK";
 414     case ECNE:
 415       return "ECNE";
 416     case CWR:
 417       return "CWR";
 418     case SHUTDOWN_COMPLETE:
 419       return "SHUTDOWN_COMPLETE";
 420     }
 421   return NULL;
 422 }
 423
 424 always_inline char *
 425 sctp_optparam_type_to_string (u8 type)
 426 {
 427   switch (type)
 428     {
 429     case SCTP_IPV4_ADDRESS_TYPE:
 430       return "SCTP_IPV4_ADDRESS_TYPE";
 431     case SCTP_IPV6_ADDRESS_TYPE:
 432       return "SCTP_IPV6_ADDRESS_TYPE";
 433     case SCTP_STATE_COOKIE_TYPE:
 434       return "SCTP_STATE_COOKIE_TYPE";
 435     case SCTP_UNRECOGNIZED_TYPE:
 436       return "SCTP_UNRECOGNIZED_TYPE";
 437     case SCTP_COOKIE_PRESERVATIVE_TYPE:
 438       return "SCTP_COOKIE_PRESERVATIVE_TYPE";
 439     case SCTP_HOSTNAME_ADDRESS_TYPE:
 440       return "SCTP_HOSTNAME_ADDRESS_TYPE";
 441     case SCTP_SUPPORTED_ADDRESS_TYPES:
 442       return "SCTP_SUPPORTED_ADDRESS_TYPES";
 443     }
 444   return NULL;
 445 }
 446
 447 #define SCTP_TICK 0.001                 /**< SCTP tick period (s) */
 448 #define SHZ (u32) (1/SCTP_TICK)         /**< SCTP tick frequency */
 449 #define SCTP_TSTAMP_RESOLUTION SCTP_TICK        /**< Time stamp resolution */
 450
 451 /* As per RFC4960, page 83 */
 452 #define SCTP_RTO_INIT 3 * SHZ   /* 3 seconds */
 453 #define SCTP_RTO_MIN 1 * SHZ    /* 1 second */
 454 #define SCTP_RTO_MAX 60 * SHZ   /* 60 seconds */
 455 #define SCTP_RTO_BURST 4
 456 #define SCTP_RTO_ALPHA 1/8
 457 #define SCTP_RTO_BETA 1/4
 458 #define SCTP_VALID_COOKIE_LIFE 60 * SHZ /* 60 seconds */
 459 #define SCTP_ASSOCIATION_MAX_RETRANS 10 // the overall connection
 460 #define SCTP_PATH_MAX_RETRANS 5 // number of attempts per destination address
 461 #define SCTP_MAX_INIT_RETRANS 8 // number of attempts
 462 #define SCTP_HB_INTERVAL 30 * SHZ
 463 #define SCTP_HB_MAX_BURST 1
 464
 465 #define SCTP_DATA_IDLE_INTERVAL 15 * SHZ        /* 15 seconds; the time-interval after which the connetion is considered IDLE */
 466
 467 #define SCTP_TO_TIMER_TICK       SCTP_TICK*10   /* Period for converting from SCTP_TICK */
 468
 469 typedef struct _sctp_lookup_dispatch
 470 {
 471   u8 next, error;
 472 } sctp_lookup_dispatch_t;
 473
 474 typedef struct _sctp_main
 475 {
 476   /* Per-worker thread SCTP connection pools */
 477   sctp_connection_t **connections;
 478
 479   /* Pool of listeners. */
 480   sctp_connection_t *listener_pool;
 481
 482           /** Dispatch table by state and flags */
 483   sctp_lookup_dispatch_t dispatch_table[SCTP_N_STATES][64];
 484
 485   u8 log2_tstamp_clocks_per_tick;
 486   f64 tstamp_ticks_per_clock;
 487   u32 *time_now;
 488
 489           /** per-worker tx buffer free lists */
 490   u32 **tx_buffers;
 491           /** per-worker tx frames to SCTP 4/6 output nodes */
 492   vlib_frame_t **tx_frames[2];
 493           /** per-worker tx frames to ip 4/6 lookup nodes */
 494   vlib_frame_t **ip_lookup_tx_frames[2];
 495
 496   /* Per worker-thread timer wheel for connections timers */
 497   tw_timer_wheel_16t_2w_512sl_t *timer_wheels;
 498
 499   /* Pool of half-open connections on which we've sent a SYN */
 500   sctp_connection_t *half_open_connections;
 501   clib_spinlock_t half_open_lock;
 502
 503   /* TODO: Congestion control algorithms registered */
 504   /* sctp_cc_algorithm_t *cc_algos; */
 505
 506   /* Flag that indicates if stack is on or off */
 507   u8 is_enabled;
 508
 509           /** Number of preallocated connections */
 510   u32 preallocated_connections;
 511
 512           /** Transport table (preallocation) size parameters */
 513   u32 local_endpoints_table_memory;
 514   u32 local_endpoints_table_buckets;
 515
 516           /** Vectors of src addresses. Optional unless one needs > 63K active-opens */
 517   ip4_address_t *ip4_src_addresses;
 518   u32 last_v4_address_rotor;
 519   u32 last_v6_address_rotor;
 520   ip6_address_t *ip6_src_addresses;
 521
 522           /** vlib buffer size */
 523   u32 bytes_per_buffer;
 524
 525   u8 punt_unknown4;
 526   u8 punt_unknown6;
 527
 528 } sctp_main_t;
 529
 530 extern sctp_main_t sctp_main;
 531 extern vlib_node_registration_t sctp4_input_node;
 532 extern vlib_node_registration_t sctp6_input_node;
 533 extern vlib_node_registration_t sctp4_output_node;
 534 extern vlib_node_registration_t sctp6_output_node;
 535
 536 always_inline sctp_main_t *
 537 vnet_get_sctp_main ()
 538 {
 539   return &sctp_main;
 540 }
 541
 542 always_inline sctp_header_t *
 543 sctp_buffer_hdr (vlib_buffer_t * b)
 544 {
 545   ASSERT ((signed) b->current_data >= (signed) -VLIB_BUFFER_PRE_DATA_SIZE);
 546   return (sctp_header_t *) (b->data + b->current_data
 547                             + vnet_buffer (b)->sctp.hdr_offset);
 548 }
 549
 550 clib_error_t *vnet_sctp_enable_disable (vlib_main_t * vm, u8 is_en);
 551
 552 always_inline sctp_connection_t *
 553 sctp_half_open_connection_get (u32 conn_index)
 554 {
 555   sctp_connection_t *tc = 0;
 556   clib_spinlock_lock_if_init (&sctp_main.half_open_lock);
 557   if (!pool_is_free_index (sctp_main.half_open_connections, conn_index))
 558     tc = pool_elt_at_index (sctp_main.half_open_connections, conn_index);
 559   tc->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx = SCTP_PRIMARY_PATH_IDX;
 560   clib_spinlock_unlock_if_init (&sctp_main.half_open_lock);
 561   return tc;
 562 }
 563
 564 /**
 565  * Cleanup half-open connection
 566  *
 567  */
 568 always_inline void
 569 sctp_half_open_connection_del (sctp_connection_t * tc)
 570 {
 571   sctp_main_t *sctp_main = vnet_get_sctp_main ();
 572   clib_spinlock_lock_if_init (&sctp_main->half_open_lock);
 573   pool_put_index (sctp_main->half_open_connections,
 574                   tc->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index);
 575   if (CLIB_DEBUG)
 576     memset (tc, 0xFA, sizeof (*tc));
 577   clib_spinlock_unlock_if_init (&sctp_main->half_open_lock);
 578 }
 579
 580 always_inline u32
 581 sctp_set_time_now (u32 thread_index)
 582 {
 583   sctp_main.time_now[thread_index] = clib_cpu_time_now ()
 584     * sctp_main.tstamp_ticks_per_clock;
 585   return sctp_main.time_now[thread_index];
 586 }
 587
 588 always_inline void
 589 sctp_timer_set (sctp_connection_t * tc, u8 conn_idx, u8 timer_id,
 590                 u32 interval)
 591 {
 592   ASSERT (tc->sub_conn[conn_idx].connection.thread_index ==
 593           vlib_get_thread_index ());
 594   ASSERT (tc->sub_conn[conn_idx].timers[timer_id] ==
 595           SCTP_TIMER_HANDLE_INVALID);
 596
 597   sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
 598   sub->timers[timer_id] =
 599     tw_timer_start_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 600                                  sub->c_c_index, timer_id, interval);
 601 }
 602
 603 always_inline void
 604 sctp_timer_reset (sctp_connection_t * tc, u8 conn_idx, u8 timer_id)
 605 {
 606   ASSERT (tc->sub_conn[conn_idx].c_thread_index == vlib_get_thread_index ());
 607   if (tc->sub_conn[conn_idx].timers[timer_id] == SCTP_TIMER_HANDLE_INVALID)
 608     return;
 609
 610   sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
 611
 612   tw_timer_stop_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 613                               sub->timers[timer_id]);
 614   sub->timers[timer_id] = SCTP_TIMER_HANDLE_INVALID;
 615 }
 616
 617 /**
 618  * Try to cleanup half-open connection
 619  *
 620  * If called from a thread that doesn't own tc, the call won't have any
 621  * effect.
 622  *
 623  * @param tc - connection to be cleaned up
 624  * @return non-zero if cleanup failed.
 625  */
 626 always_inline int
 627 sctp_half_open_connection_cleanup (sctp_connection_t * tc)
 628 {
 629   /* Make sure this is the owning thread */
 630   if (tc->sub_conn[SCTP_PRIMARY_PATH_IDX].c_thread_index !=
 631       vlib_get_thread_index ())
 632     return 1;
 633   sctp_timer_reset (tc, SCTP_PRIMARY_PATH_IDX, SCTP_TIMER_T1_INIT);
 634   sctp_half_open_connection_del (tc);
 635   return 0;
 636 }
 637
 638 always_inline u32
 639 sctp_header_bytes ()
 640 {
 641   return sizeof (sctp_header_t);
 642 }
 643
 644 always_inline sctp_connection_t *
 645 sctp_get_connection_from_transport (transport_connection_t * tconn)
 646 {
 647   ASSERT (tconn != NULL);
 648
 649   sctp_sub_connection_t *sub = (sctp_sub_connection_t *) tconn;
 650 #if SCTP_ADV_DEBUG
 651   if (sub == NULL)
 652     SCTP_ADV_DBG ("sub == NULL");
 653   if (sub->parent == NULL)
 654     SCTP_ADV_DBG ("sub->parent == NULL");
 655 #endif
 656   if (sub->subconn_idx > 0)
 657     return (sctp_connection_t *) sub -
 658       (sizeof (sctp_sub_connection_t) * (sub->subconn_idx - 1));
 659
 660   return (sctp_connection_t *) sub;
 661 }
 662
 663 always_inline u32
 664 sctp_time_now (void)
 665 {
 666   return sctp_main.time_now[vlib_get_thread_index ()];
 667 }
 668
 669 #define ABS(x) ((x) > 0) ? (x) : -(x);
 670
 671 always_inline void
 672 sctp_calculate_rto (sctp_connection_t * sctp_conn, u8 conn_idx)
 673 {
 674   /* See RFC4960, 6.3.1.  RTO Calculation */
 675   u32 RTO = 0;
 676   f32 RTTVAR = 0;
 677   u32 now = sctp_time_now ();
 678   u32 prev_ts = sctp_conn->sub_conn[conn_idx].rtt_ts;
 679   u32 R = prev_ts - now;
 680
 681   if (sctp_conn->sub_conn[conn_idx].RTO == 0)   // C1: Let's initialize our RTO
 682     {
 683       sctp_conn->sub_conn[conn_idx].RTO = SCTP_RTO_MIN;
 684       return;
 685     }
 686
 687   if (sctp_conn->sub_conn[conn_idx].RTO == SCTP_RTO_MIN && sctp_conn->sub_conn[conn_idx].SRTT == 0)     // C2: First RTT calculation
 688     {
 689       sctp_conn->sub_conn[conn_idx].SRTT = R;
 690       RTTVAR = R / 2;
 691
 692       if (RTTVAR == 0)
 693         RTTVAR = 100e-3;        /* 100 ms */
 694
 695       sctp_conn->sub_conn[conn_idx].RTTVAR = RTTVAR;
 696     }
 697   else                          // C3: RTT already exists; let's recalculate
 698     {
 699       RTTVAR = (1 - SCTP_RTO_BETA) * sctp_conn->sub_conn[conn_idx].RTTVAR +
 700         SCTP_RTO_BETA * ABS (sctp_conn->sub_conn[conn_idx].SRTT - R);
 701
 702       if (RTTVAR == 0)
 703         RTTVAR = 100e-3;        /* 100 ms */
 704
 705       sctp_conn->sub_conn[conn_idx].RTTVAR = RTTVAR;
 706
 707       sctp_conn->sub_conn[conn_idx].SRTT =
 708         (1 - SCTP_RTO_ALPHA) * sctp_conn->sub_conn[conn_idx].SRTT +
 709         SCTP_RTO_ALPHA * R;
 710     }
 711
 712   RTO =
 713     sctp_conn->sub_conn[conn_idx].SRTT +
 714     4 * sctp_conn->sub_conn[conn_idx].RTTVAR;
 715   if (RTO < SCTP_RTO_MIN)       // C6
 716     RTO = SCTP_RTO_MIN;
 717
 718   if (RTO > SCTP_RTO_MAX)       // C7
 719     RTO = SCTP_RTO_MAX;
 720
 721   sctp_conn->sub_conn[conn_idx].RTO = RTO;
 722 }
 723
 724 always_inline void
 725 sctp_timer_update (sctp_connection_t * tc, u8 conn_idx, u8 timer_id,
 726                    u32 interval)
 727 {
 728   ASSERT (tc->sub_conn[conn_idx].connection.thread_index ==
 729           vlib_get_thread_index ());
 730   sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
 731
 732   if (tc->sub_conn[conn_idx].timers[timer_id] != SCTP_TIMER_HANDLE_INVALID)
 733     tw_timer_stop_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 734                                 sub->timers[timer_id]);
 735
 736   tc->sub_conn[conn_idx].timers[timer_id] =
 737     tw_timer_start_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
 738                                  sub->c_c_index, timer_id, interval);
 739 }
 740
 741 always_inline sctp_connection_t *
 742 sctp_listener_get (u32 tli)
 743 {
 744   return pool_elt_at_index (sctp_main.listener_pool, tli);
 745 }
 746
 747 #endif
 748
 749 always_inline sctp_connection_t *
 750 sctp_connection_get (u32 conn_index, u32 thread_index)
 751 {
 752   if (PREDICT_FALSE
 753       (pool_is_free_index (sctp_main.connections[thread_index], conn_index)))
 754     return 0;
 755   return pool_elt_at_index (sctp_main.connections[thread_index], conn_index);
 756 }
 757
 758 #define SELECT_MAX_RETRIES 8
 759
 760 always_inline u8
 761 sctp_data_subconn_select (sctp_connection_t * sctp_conn)
 762 {
 763   u32 sub = SCTP_PRIMARY_PATH_IDX;
 764   u8 i, cwnd = sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].cwnd;
 765   for (i = 1; i < MAX_SCTP_CONNECTIONS; i++)
 766     {
 767       if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
 768         continue;
 769
 770       if (sctp_conn->sub_conn[i].cwnd > cwnd)
 771         {
 772           sub = i;
 773           cwnd = sctp_conn->sub_conn[i].cwnd;
 774         }
 775     }
 776   return sub;
 777 }
 778
 779 always_inline u8
 780 sctp_sub_conn_id_via_ip6h (sctp_connection_t * sctp_conn, ip6_header_t * ip6h)
 781 {
 782   u8 i;
 783
 784   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 785     {
 786       if (sctp_conn->sub_conn[i].connection.lcl_ip.ip6.as_u64[0] ==
 787           ip6h->dst_address.as_u64[0] &&
 788           sctp_conn->sub_conn[i].connection.lcl_ip.ip6.as_u64[1] ==
 789           ip6h->dst_address.as_u64[1] &&
 790           sctp_conn->sub_conn[i].connection.rmt_ip.ip6.as_u64[0] ==
 791           ip6h->src_address.as_u64[0] &&
 792           sctp_conn->sub_conn[i].connection.rmt_ip.ip6.as_u64[1] ==
 793           ip6h->src_address.as_u64[1])
 794         return i;
 795     }
 796   clib_warning ("Did not find a sub-connection; defaulting to %u",
 797                 SCTP_PRIMARY_PATH_IDX);
 798   return SCTP_PRIMARY_PATH_IDX;
 799 }
 800
 801 always_inline u8
 802 sctp_sub_conn_id_via_ip4h (sctp_connection_t * sctp_conn, ip4_header_t * ip4h)
 803 {
 804   u8 i;
 805
 806   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 807     {
 808       if (sctp_conn->sub_conn[i].connection.lcl_ip.ip4.as_u32 ==
 809           ip4h->dst_address.as_u32
 810           && sctp_conn->sub_conn[i].connection.rmt_ip.ip4.as_u32 ==
 811           ip4h->src_address.as_u32)
 812         return i;
 813     }
 814   clib_warning ("Did not find a sub-connection; defaulting to %u",
 815                 SCTP_PRIMARY_PATH_IDX);
 816   return SCTP_PRIMARY_PATH_IDX;
 817 }
 818
 819 /**
 820  * Push SCTP header to buffer
 821  *
 822  * @param vm - vlib_main
 823  * @param b - buffer to write the header to
 824  * @param sp_net - source port net order
 825  * @param dp_net - destination port net order
 826  * @param sctp_hdr_opts_len - header and options length in bytes
 827  *
 828  * @return - pointer to start of SCTP header
 829  */
 830 always_inline void *
 831 vlib_buffer_push_sctp_net_order (vlib_buffer_t * b, u16 sp, u16 dp,
 832                                  u8 sctp_hdr_opts_len)
 833 {
 834   sctp_full_hdr_t *full_hdr;
 835
 836   full_hdr = vlib_buffer_push_uninit (b, sctp_hdr_opts_len);
 837
 838   full_hdr->hdr.src_port = sp;
 839   full_hdr->hdr.dst_port = dp;
 840   full_hdr->hdr.checksum = 0;
 841   return full_hdr;
 842 }
 843
 844 /**
 845  * Push SCTP header to buffer
 846  *
 847  * @param b - buffer to write the header to
 848  * @param sp_net - source port net order
 849  * @param dp_net - destination port net order
 850  * @param sctp_hdr_opts_len - header and options length in bytes
 851  *
 852  * @return - pointer to start of SCTP header
 853  */
 854 always_inline void *
 855 vlib_buffer_push_sctp (vlib_buffer_t * b, u16 sp_net, u16 dp_net,
 856                        u8 sctp_hdr_opts_len)
 857 {
 858   return vlib_buffer_push_sctp_net_order (b, sp_net, dp_net,
 859                                           sctp_hdr_opts_len);
 860 }
 861
 862 always_inline u8
 863 sctp_next_avail_subconn (sctp_connection_t * sctp_conn)
 864 {
 865   u8 i;
 866
 867   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 868     {
 869       if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
 870         return i;
 871     }
 872   return MAX_SCTP_CONNECTIONS;
 873 }
 874
 875 always_inline void
 876 update_smallest_pmtu_idx (sctp_connection_t * sctp_conn)
 877 {
 878   u8 i;
 879   u8 smallest_pmtu_index = SCTP_PRIMARY_PATH_IDX;
 880
 881   for (i = 1; i < MAX_SCTP_CONNECTIONS; i++)
 882     {
 883       if (sctp_conn->sub_conn[i].state != SCTP_SUBCONN_STATE_DOWN)
 884         {
 885           if (sctp_conn->sub_conn[i].PMTU <
 886               sctp_conn->sub_conn[smallest_pmtu_index].PMTU)
 887             smallest_pmtu_index = i;
 888         }
 889     }
 890
 891   sctp_conn->smallest_PMTU_idx = smallest_pmtu_index;
 892 }
 893
 894 /* As per RFC4960; section 7.2.1: Slow-Start */
 895 always_inline void
 896 sctp_init_cwnd (sctp_connection_t * sctp_conn)
 897 {
 898   u8 i;
 899   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 900     {
 901       /* Section 7.2.1; point (1) */
 902       sctp_conn->sub_conn[i].cwnd =
 903         clib_min (4 * sctp_conn->sub_conn[i].PMTU,
 904                   clib_max (2 * sctp_conn->sub_conn[i].PMTU, 4380));
 905
 906       /* Section 7.2.1; point (3) */
 907       sctp_conn->sub_conn[i].ssthresh = SCTP_INITIAL_SSHTRESH;
 908
 909       /* Section 7.2.2; point (1) */
 910       sctp_conn->sub_conn[i].partially_acked_bytes = 0;
 911     }
 912 }
 913
 914 always_inline u8
 915 sctp_in_cong_recovery (sctp_connection_t * sctp_conn, u8 idx)
 916 {
 917   return 0;
 918 }
 919
 920 always_inline u8
 921 cwnd_fully_utilized (sctp_connection_t * sctp_conn, u8 idx)
 922 {
 923   return 0;
 924 }
 925
 926 /* As per RFC4960; section 7.2.1: Slow-Start */
 927 always_inline void
 928 update_cwnd (sctp_connection_t * sctp_conn)
 929 {
 930   u8 i;
 931
 932   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
 933     {
 934       /* Section 7.2.1; point (2) */
 935       if (sctp_conn->sub_conn[i].is_retransmitting)
 936         {
 937           sctp_conn->sub_conn[i].cwnd = 1 * sctp_conn->sub_conn[i].PMTU;
 938           continue;
 939         }
 940
 941       /* Section 7.2.2; point (4) */
 942       if (sctp_conn->sub_conn[i].last_data_ts >
 943           sctp_time_now () + SCTP_DATA_IDLE_INTERVAL)
 944         {
 945           sctp_conn->sub_conn[i].cwnd =
 946             clib_max (sctp_conn->sub_conn[i].cwnd / 2,
 947                       4 * sctp_conn->sub_conn[i].PMTU);
 948           continue;
 949         }
 950
 951       /* Section 7.2.1; point (5) */
 952       if (sctp_conn->sub_conn[i].cwnd <= sctp_conn->sub_conn[i].ssthresh)
 953         {
 954           if (!cwnd_fully_utilized (sctp_conn, i))
 955             continue;
 956
 957           if (sctp_in_cong_recovery (sctp_conn, i))
 958             continue;
 959
 960           sctp_conn->sub_conn[i].cwnd =
 961             clib_min (sctp_conn->sub_conn[i].PMTU, 1);
 962         }
 963     }
 964 }
 965
 966 /*
 967  * fd.io coding-style-patch-verification: ON
 968  *
 969  * Local Variables:
 970  * eval: (c-set-style "gnu")
 971  * End:
 972  */