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