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