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