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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
15 #ifndef included_vnet_sctp_h
16 #define included_vnet_sctp_h
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>
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")
34 typedef enum _sctp_timers
36 #define _(sym, str) SCTP_TIMER_##sym,
42 #define SCTP_TIMER_HANDLE_INVALID ((u32) ~0)
45 sctp_timer_to_string (u8 timer_id)
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";
65 typedef enum _sctp_error
67 #define sctp_error(n,s) SCTP_ERROR_##n,
68 #include <vnet/sctp/sctp_error.def>
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))
80 #define MAX_SCTP_CONNECTIONS 8
81 #define MAIN_SCTP_SUB_CONN_IDX 0
83 #if (VLIB_BUFFER_TRACE_TRAJECTORY)
84 #define sctp_trajectory_add_start(b, start) \
86 (*vlib_buffer_trace_trajectory_cb) (b, start); \
89 #define sctp_trajectory_add_start(b, start)
92 enum _sctp_subconn_state
94 SCTP_SUBCONN_STATE_DOWN = 0,
95 SCTP_SUBCONN_STATE_UP,
96 SCTP_SUBCONN_STATE_ALLOW_HB
99 #define SCTP_INITIAL_SSHTRESH 65535
100 typedef struct _sctp_sub_connection
102 transport_connection_t connection; /**< Common transport data. First! */
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. */
113 u32 rtt_ts; /**< USED to hold the timestamp of when the packet has been sent */
115 u32 RTO; /**< The current retransmission timeout value. */
116 u32 SRTT; /**< The current smoothed round-trip time. */
117 f32 RTTVAR; /**< The current RTT variation. */
119 u32 partially_acked_bytes; /**< The tracking method for increase of cwnd when in
120 congestion avoidance mode (see Section 7.2.2).*/
122 u8 state; /**< The current state of this destination, i.e., DOWN, UP, ALLOW-HB, NO-HEARTBEAT, etc. */
124 u16 PMTU; /**< The current known path MTU. */
126 u32 timers[SCTP_N_TIMERS]; /**< A timer used by each destination. */
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),
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. */
138 u32 last_data_ts; /**< Used to hold the timestamp value of last time we sent a DATA chunk */
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. */
143 u8 is_retransmitting; /**< A flag (0 = no, 1 = yes) indicating whether the connection is retransmitting a previous packet */
145 u8 enqueue_state; /**< if set to 1 indicates that DATA is still being handled hence cannot shutdown this connection yet */
147 } sctp_sub_connection_t;
151 u32 a_rwnd; /**< Maximum segment size advertised */
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)) )
161 _bytes_swap (void *pv, size_t n)
165 for (lo = 0, hi = n - 1; hi > lo; lo++, hi--)
173 #define ENDIANESS_SWAP(x) _bytes_swap(&x, sizeof(x));
175 #define MAX_INFLIGHT_PACKETS 128
176 #define MAX_ENQUEABLE_SACKS 2
178 /* This parameter indicates to the receiver how much increment in
179 * milliseconds the sender wishes the receiver to add to its default
182 #define SUGGESTED_COOKIE_LIFE_SPAN_INCREMENT 1000
184 typedef struct _sctp_connection
186 sctp_sub_connection_t sub_conn[MAX_SCTP_CONNECTIONS]; /**< Common transport data. First! */
188 u8 state; /**< SCTP state as per sctp_state_t */
189 u16 flags; /**< Chunk flag (see sctp_chunks_common_hdr_t) */
191 u32 local_tag; /**< INIT_TAG generated locally */
192 u32 remote_tag; /**< INIT_TAG generated by the remote peer */
194 u32 local_initial_tsn; /**< Initial TSN generated locally */
195 u32 remote_initial_tsn; /**< Initial TSN generated by the remote-peer */
197 u32 peer_cookie_life_span_increment;
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. */
203 u32 peer_rwnd; /**< Current calculated value of the peer's rwnd. */
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
211 u32 last_unacked_tsn; /** < Last TSN number still unacked */
212 u32 next_tsn_expected; /**< The next TSN number expected to be received. */
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. */
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. */
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). */
230 u8 smallest_PMTU_idx; /** The index of the sub-connection with the smallest PMTU discovered across all peer's transport addresses. */
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 */
236 sctp_options_t snd_opts;
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. */
243 typedef void (sctp_timer_expiration_handler) (u32 conn_index, u32 timer_id);
245 sctp_connection_t *sctp_connection_new (u8 thread_index);
248 sctp_sub_connection_add_ip4 (vlib_main_t * vm,
249 ip4_address_t * lcl_addr,
250 ip4_address_t * rmt_addr);
253 sctp_sub_connection_add_ip6 (vlib_main_t * vm,
254 ip6_address_t * lcl_addr,
255 ip6_address_t * rmt_addr);
258 sctp_sub_connection_del_ip4 (ip4_address_t * lcl_addr,
259 ip4_address_t * rmt_addr);
262 sctp_sub_connection_del_ip6 (ip6_address_t * lcl_addr,
263 ip6_address_t * rmt_addr);
265 void sctp_connection_close (sctp_connection_t * sctp_conn);
266 void sctp_connection_cleanup (sctp_connection_t * sctp_conn);
267 void sctp_connection_del (sctp_connection_t * sctp_conn);
269 u32 sctp_push_header (transport_connection_t * tconn, vlib_buffer_t * b);
270 void sctp_send_init (sctp_connection_t * sctp_conn);
271 void sctp_send_shutdown (sctp_connection_t * sctp_conn);
272 void sctp_send_shutdown_ack (sctp_connection_t * sctp_conn, u8 idx,
274 void sctp_send_shutdown_complete (sctp_connection_t * sctp_conn, u8 idx,
276 void sctp_send_heartbeat (sctp_connection_t * sctp_conn);
277 void sctp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index,
279 void sctp_flush_frames_to_output (u8 thread_index);
280 void sctp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add);
282 format_function_t format_sctp_state;
284 u8 *format_sctp_connection_id (u8 * s, va_list * args);
285 u8 *format_sctp_connection (u8 * s, va_list * args);
286 u8 *format_sctp_scoreboard (u8 * s, va_list * args);
287 u8 *format_sctp_header (u8 * s, va_list * args);
288 u8 *format_sctp_tx_trace (u8 * s, va_list * args);
290 clib_error_t *sctp_init (vlib_main_t * vm);
291 void sctp_connection_timers_init (sctp_connection_t * sctp_conn);
292 void sctp_connection_timers_reset (sctp_connection_t * sctp_conn);
293 void sctp_init_snd_vars (sctp_connection_t * sctp_conn);
294 void sctp_init_mss (sctp_connection_t * sctp_conn);
296 void sctp_prepare_initack_chunk (sctp_connection_t * sctp_conn, u8 idx,
297 vlib_buffer_t * b, ip4_address_t * ip4_addr,
298 ip6_address_t * ip6_addr);
300 sctp_prepare_initack_chunk_for_collision (sctp_connection_t * sctp_conn,
301 u8 idx, vlib_buffer_t * b,
302 ip4_address_t * ip4_addr,
303 ip6_address_t * ip6_addr);
304 void sctp_prepare_abort_for_collision (sctp_connection_t * sctp_conn, u8 idx,
306 ip4_address_t * ip4_addr,
307 ip6_address_t * ip6_addr);
309 sctp_prepare_operation_error (sctp_connection_t * sctp_conn, u8 idx,
310 vlib_buffer_t * b, u8 err_cause);
311 void sctp_prepare_cookie_echo_chunk (sctp_connection_t * sctp_conn, u8 idx,
313 sctp_state_cookie_param_t * sc);
314 void sctp_prepare_cookie_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
316 void sctp_prepare_sack_chunk (sctp_connection_t * sctp_conn, u8 idx,
318 void sctp_prepare_heartbeat_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
321 u16 sctp_check_outstanding_data_chunks (sctp_connection_t * sctp_conn);
323 void sctp_api_reference (void);
325 #define IP_PROTOCOL_SCTP 132
327 /** SSCTP FSM state definitions as per RFC4960. */
328 #define foreach_sctp_fsm_state \
329 _(CLOSED, "CLOSED") \
330 _(COOKIE_WAIT, "COOKIE_WAIT") \
331 _(COOKIE_ECHOED, "COOKIE_ECHOED") \
332 _(ESTABLISHED, "ESTABLISHED") \
333 _(SHUTDOWN_PENDING, "SHUTDOWN_PENDING") \
334 _(SHUTDOWN_SENT, "SHUTDOWN_SENT") \
335 _(SHUTDOWN_RECEIVED, "SHUTDOWN_RECEIVED") \
336 _(SHUTDOWN_ACK_SENT, "SHUTDOWN_ACK_SENT")
338 typedef enum _sctp_state
340 #define _(sym, str) SCTP_STATE_##sym,
341 foreach_sctp_fsm_state
347 sctp_state_to_string (u8 state)
351 case SCTP_STATE_CLOSED:
352 return "SCTP_STATE_CLOSED";
353 case SCTP_STATE_COOKIE_WAIT:
354 return "SCTP_STATE_COOKIE_WAIT";
355 case SCTP_STATE_COOKIE_ECHOED:
356 return "SCTP_STATE_COOKIE_ECHOED";
357 case SCTP_STATE_ESTABLISHED:
358 return "SCTP_STATE_ESTABLISHED";
359 case SCTP_STATE_SHUTDOWN_PENDING:
360 return "SCTP_STATE_SHUTDOWN_PENDING";
361 case SCTP_STATE_SHUTDOWN_SENT:
362 return "SCTP_STATE_SHUTDOWN_SENT";
363 case SCTP_STATE_SHUTDOWN_RECEIVED:
364 return "SCTP_STATE_SHUTDOWN_RECEIVED";
365 case SCTP_STATE_SHUTDOWN_ACK_SENT:
366 return "SCTP_STATE_SHUTDOWN_ACK_SENT";
372 sctp_chunk_to_string (u8 type)
387 return "HEARTBEAT_ACK";
393 return "SHUTDOWN_ACK";
394 case OPERATION_ERROR:
395 return "OPERATION_ERROR";
397 return "COOKIE_ECHO";
404 case SHUTDOWN_COMPLETE:
405 return "SHUTDOWN_COMPLETE";
411 sctp_optparam_type_to_string (u8 type)
415 case SCTP_IPV4_ADDRESS_TYPE:
416 return "SCTP_IPV4_ADDRESS_TYPE";
417 case SCTP_IPV6_ADDRESS_TYPE:
418 return "SCTP_IPV6_ADDRESS_TYPE";
419 case SCTP_STATE_COOKIE_TYPE:
420 return "SCTP_STATE_COOKIE_TYPE";
421 case SCTP_UNRECOGNIZED_TYPE:
422 return "SCTP_UNRECOGNIZED_TYPE";
423 case SCTP_COOKIE_PRESERVATIVE_TYPE:
424 return "SCTP_COOKIE_PRESERVATIVE_TYPE";
425 case SCTP_HOSTNAME_ADDRESS_TYPE:
426 return "SCTP_HOSTNAME_ADDRESS_TYPE";
427 case SCTP_SUPPORTED_ADDRESS_TYPES:
428 return "SCTP_SUPPORTED_ADDRESS_TYPES";
433 #define SCTP_TICK 0.001 /**< SCTP tick period (s) */
434 #define SHZ (u32) (1/SCTP_TICK) /**< SCTP tick frequency */
435 #define SCTP_TSTAMP_RESOLUTION SCTP_TICK /**< Time stamp resolution */
437 /* As per RFC4960, page 83 */
438 #define SCTP_RTO_INIT 3 * SHZ /* 3 seconds */
439 #define SCTP_RTO_MIN 1 * SHZ /* 1 second */
440 #define SCTP_RTO_MAX 60 * SHZ /* 60 seconds */
441 #define SCTP_RTO_BURST 4
442 #define SCTP_RTO_ALPHA 1/8
443 #define SCTP_RTO_BETA 1/4
444 #define SCTP_VALID_COOKIE_LIFE 60 * SHZ /* 60 seconds */
445 #define SCTP_ASSOCIATION_MAX_RETRANS 10 // the overall connection
446 #define SCTP_PATH_MAX_RETRANS 5 // number of attempts per destination address
447 #define SCTP_MAX_INIT_RETRANS 8 // number of attempts
448 #define SCTP_HB_INTERVAL 30 * SHZ
449 #define SCTP_HB_MAX_BURST 1
451 #define SCTP_DATA_IDLE_INTERVAL 15 * SHZ /* 15 seconds; the time-interval after which the connetion is considered IDLE */
453 #define SCTP_TO_TIMER_TICK SCTP_TICK*10 /* Period for converting from SCTP_TICK */
455 typedef struct _sctp_lookup_dispatch
458 } sctp_lookup_dispatch_t;
460 typedef struct _sctp_main
462 /* Per-worker thread SCTP connection pools */
463 sctp_connection_t **connections;
465 /* Pool of listeners. */
466 sctp_connection_t *listener_pool;
468 /** Dispatch table by state and flags */
469 sctp_lookup_dispatch_t dispatch_table[SCTP_N_STATES][64];
471 u8 log2_tstamp_clocks_per_tick;
472 f64 tstamp_ticks_per_clock;
475 /** per-worker tx buffer free lists */
477 /** per-worker tx frames to SCTP 4/6 output nodes */
478 vlib_frame_t **tx_frames[2];
479 /** per-worker tx frames to ip 4/6 lookup nodes */
480 vlib_frame_t **ip_lookup_tx_frames[2];
482 /* Per worker-thread timer wheel for connections timers */
483 tw_timer_wheel_16t_2w_512sl_t *timer_wheels;
485 /* Pool of half-open connections on which we've sent a SYN */
486 sctp_connection_t *half_open_connections;
487 clib_spinlock_t half_open_lock;
489 /* TODO: Congestion control algorithms registered */
490 /* sctp_cc_algorithm_t *cc_algos; */
492 /* Flag that indicates if stack is on or off */
495 /** Number of preallocated connections */
496 u32 preallocated_connections;
498 /** Transport table (preallocation) size parameters */
499 u32 local_endpoints_table_memory;
500 u32 local_endpoints_table_buckets;
502 /** Vectors of src addresses. Optional unless one needs > 63K active-opens */
503 ip4_address_t *ip4_src_addresses;
504 u32 last_v4_address_rotor;
505 u32 last_v6_address_rotor;
506 ip6_address_t *ip6_src_addresses;
508 /** vlib buffer size */
509 u32 bytes_per_buffer;
516 extern sctp_main_t sctp_main;
517 extern vlib_node_registration_t sctp4_input_node;
518 extern vlib_node_registration_t sctp6_input_node;
519 extern vlib_node_registration_t sctp4_output_node;
520 extern vlib_node_registration_t sctp6_output_node;
522 always_inline sctp_main_t *
523 vnet_get_sctp_main ()
528 always_inline sctp_header_t *
529 sctp_buffer_hdr (vlib_buffer_t * b)
531 ASSERT ((signed) b->current_data >= (signed) -VLIB_BUFFER_PRE_DATA_SIZE);
532 return (sctp_header_t *) (b->data + b->current_data
533 + vnet_buffer (b)->sctp.hdr_offset);
536 clib_error_t *vnet_sctp_enable_disable (vlib_main_t * vm, u8 is_en);
538 always_inline sctp_connection_t *
539 sctp_half_open_connection_get (u32 conn_index)
541 sctp_connection_t *tc = 0;
542 clib_spinlock_lock_if_init (&sctp_main.half_open_lock);
543 if (!pool_is_free_index (sctp_main.half_open_connections, conn_index))
544 tc = pool_elt_at_index (sctp_main.half_open_connections, conn_index);
545 tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].subconn_idx = MAIN_SCTP_SUB_CONN_IDX;
546 clib_spinlock_unlock_if_init (&sctp_main.half_open_lock);
551 * Cleanup half-open connection
555 sctp_half_open_connection_del (sctp_connection_t * tc)
557 sctp_main_t *sctp_main = vnet_get_sctp_main ();
558 clib_spinlock_lock_if_init (&sctp_main->half_open_lock);
559 pool_put_index (sctp_main->half_open_connections,
560 tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index);
562 memset (tc, 0xFA, sizeof (*tc));
563 clib_spinlock_unlock_if_init (&sctp_main->half_open_lock);
567 sctp_set_time_now (u32 thread_index)
569 sctp_main.time_now[thread_index] = clib_cpu_time_now ()
570 * sctp_main.tstamp_ticks_per_clock;
571 return sctp_main.time_now[thread_index];
575 sctp_timer_set (sctp_connection_t * tc, u8 conn_idx, u8 timer_id,
578 ASSERT (tc->sub_conn[conn_idx].connection.thread_index ==
579 vlib_get_thread_index ());
580 ASSERT (tc->sub_conn[conn_idx].timers[timer_id] ==
581 SCTP_TIMER_HANDLE_INVALID);
583 sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
584 sub->timers[timer_id] =
585 tw_timer_start_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
586 sub->c_c_index, timer_id, interval);
590 sctp_timer_reset (sctp_connection_t * tc, u8 conn_idx, u8 timer_id)
592 ASSERT (tc->sub_conn[conn_idx].c_thread_index == vlib_get_thread_index ());
593 if (tc->sub_conn[conn_idx].timers[timer_id] == SCTP_TIMER_HANDLE_INVALID)
596 sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
598 tw_timer_stop_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
599 sub->timers[timer_id]);
600 sub->timers[timer_id] = SCTP_TIMER_HANDLE_INVALID;
604 * Try to cleanup half-open connection
606 * If called from a thread that doesn't own tc, the call won't have any
609 * @param tc - connection to be cleaned up
610 * @return non-zero if cleanup failed.
613 sctp_half_open_connection_cleanup (sctp_connection_t * tc)
615 /* Make sure this is the owning thread */
616 if (tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_thread_index !=
617 vlib_get_thread_index ())
619 sctp_timer_reset (tc, MAIN_SCTP_SUB_CONN_IDX, SCTP_TIMER_T1_INIT);
620 sctp_half_open_connection_del (tc);
627 return sizeof (sctp_header_t);
630 always_inline sctp_connection_t *
631 sctp_get_connection_from_transport (transport_connection_t * tconn)
633 ASSERT (tconn != NULL);
635 sctp_sub_connection_t *sub = (sctp_sub_connection_t *) tconn;
638 SCTP_ADV_DBG ("sub == NULL");
639 if (sub->parent == NULL)
640 SCTP_ADV_DBG ("sub->parent == NULL");
642 if (sub->subconn_idx > 0)
643 return (sctp_connection_t *) sub -
644 (sizeof (sctp_sub_connection_t) * (sub->subconn_idx - 1));
646 return (sctp_connection_t *) sub;
652 return sctp_main.time_now[vlib_get_thread_index ()];
655 #define ABS(x) ((x) > 0) ? (x) : -(x);
658 sctp_calculate_rto (sctp_connection_t * sctp_conn, u8 conn_idx)
660 /* See RFC4960, 6.3.1. RTO Calculation */
663 u32 now = sctp_time_now ();
664 u32 prev_ts = sctp_conn->sub_conn[conn_idx].rtt_ts;
665 u32 R = prev_ts - now;
667 if (sctp_conn->sub_conn[conn_idx].RTO == 0) // C1: Let's initialize our RTO
669 sctp_conn->sub_conn[conn_idx].RTO = SCTP_RTO_MIN;
673 if (sctp_conn->sub_conn[conn_idx].RTO == SCTP_RTO_MIN && sctp_conn->sub_conn[conn_idx].SRTT == 0) // C2: First RTT calculation
675 sctp_conn->sub_conn[conn_idx].SRTT = R;
679 RTTVAR = 100e-3; /* 100 ms */
681 sctp_conn->sub_conn[conn_idx].RTTVAR = RTTVAR;
683 else // C3: RTT already exists; let's recalculate
685 RTTVAR = (1 - SCTP_RTO_BETA) * sctp_conn->sub_conn[conn_idx].RTTVAR +
686 SCTP_RTO_BETA * ABS (sctp_conn->sub_conn[conn_idx].SRTT - R);
689 RTTVAR = 100e-3; /* 100 ms */
691 sctp_conn->sub_conn[conn_idx].RTTVAR = RTTVAR;
693 sctp_conn->sub_conn[conn_idx].SRTT =
694 (1 - SCTP_RTO_ALPHA) * sctp_conn->sub_conn[conn_idx].SRTT +
699 sctp_conn->sub_conn[conn_idx].SRTT +
700 4 * sctp_conn->sub_conn[conn_idx].RTTVAR;
701 if (RTO < SCTP_RTO_MIN) // C6
704 if (RTO > SCTP_RTO_MAX) // C7
707 sctp_conn->sub_conn[conn_idx].RTO = RTO;
711 sctp_timer_update (sctp_connection_t * tc, u8 conn_idx, u8 timer_id,
714 ASSERT (tc->sub_conn[conn_idx].connection.thread_index ==
715 vlib_get_thread_index ());
716 sctp_sub_connection_t *sub = &tc->sub_conn[conn_idx];
718 if (tc->sub_conn[conn_idx].timers[timer_id] != SCTP_TIMER_HANDLE_INVALID)
719 tw_timer_stop_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
720 sub->timers[timer_id]);
722 tc->sub_conn[conn_idx].timers[timer_id] =
723 tw_timer_start_16t_2w_512sl (&sctp_main.timer_wheels[sub->c_thread_index],
724 sub->c_c_index, timer_id, interval);
727 always_inline sctp_connection_t *
728 sctp_listener_get (u32 tli)
730 return pool_elt_at_index (sctp_main.listener_pool, tli);
735 always_inline sctp_connection_t *
736 sctp_connection_get (u32 conn_index, u32 thread_index)
739 (pool_is_free_index (sctp_main.connections[thread_index], conn_index)))
741 return pool_elt_at_index (sctp_main.connections[thread_index], conn_index);
744 #define SELECT_MAX_RETRIES 8
747 sctp_data_subconn_select (sctp_connection_t * sctp_conn)
749 u32 sub = MAIN_SCTP_SUB_CONN_IDX;
750 u8 i, cwnd = sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].cwnd;
751 for (i = 1; i < MAX_SCTP_CONNECTIONS; i++)
753 if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
756 if (sctp_conn->sub_conn[i].cwnd > cwnd)
759 cwnd = sctp_conn->sub_conn[i].cwnd;
766 sctp_sub_conn_id_via_ip6h (sctp_connection_t * sctp_conn, ip6_header_t * ip6h)
770 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
772 if (sctp_conn->sub_conn[i].connection.lcl_ip.ip6.as_u64[0] ==
773 ip6h->dst_address.as_u64[0] &&
774 sctp_conn->sub_conn[i].connection.lcl_ip.ip6.as_u64[1] ==
775 ip6h->dst_address.as_u64[1] &&
776 sctp_conn->sub_conn[i].connection.rmt_ip.ip6.as_u64[0] ==
777 ip6h->src_address.as_u64[0] &&
778 sctp_conn->sub_conn[i].connection.rmt_ip.ip6.as_u64[1] ==
779 ip6h->src_address.as_u64[1])
782 clib_warning ("Did not find a sub-connection; defaulting to %u",
783 MAIN_SCTP_SUB_CONN_IDX);
784 return MAIN_SCTP_SUB_CONN_IDX;
788 sctp_sub_conn_id_via_ip4h (sctp_connection_t * sctp_conn, ip4_header_t * ip4h)
792 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
794 if (sctp_conn->sub_conn[i].connection.lcl_ip.ip4.as_u32 ==
795 ip4h->dst_address.as_u32
796 && sctp_conn->sub_conn[i].connection.rmt_ip.ip4.as_u32 ==
797 ip4h->src_address.as_u32)
800 clib_warning ("Did not find a sub-connection; defaulting to %u",
801 MAIN_SCTP_SUB_CONN_IDX);
802 return MAIN_SCTP_SUB_CONN_IDX;
806 * Push SCTP header to buffer
808 * @param vm - vlib_main
809 * @param b - buffer to write the header to
810 * @param sp_net - source port net order
811 * @param dp_net - destination port net order
812 * @param sctp_hdr_opts_len - header and options length in bytes
814 * @return - pointer to start of SCTP header
817 vlib_buffer_push_sctp_net_order (vlib_buffer_t * b, u16 sp, u16 dp,
818 u8 sctp_hdr_opts_len)
820 sctp_full_hdr_t *full_hdr;
822 full_hdr = vlib_buffer_push_uninit (b, sctp_hdr_opts_len);
824 full_hdr->hdr.src_port = sp;
825 full_hdr->hdr.dst_port = dp;
826 full_hdr->hdr.checksum = 0;
831 * Push SCTP header to buffer
833 * @param b - buffer to write the header to
834 * @param sp_net - source port net order
835 * @param dp_net - destination port net order
836 * @param sctp_hdr_opts_len - header and options length in bytes
838 * @return - pointer to start of SCTP header
841 vlib_buffer_push_sctp (vlib_buffer_t * b, u16 sp_net, u16 dp_net,
842 u8 sctp_hdr_opts_len)
844 return vlib_buffer_push_sctp_net_order (b, sp_net, dp_net,
849 sctp_next_avail_subconn (sctp_connection_t * sctp_conn)
853 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
855 if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
858 return MAX_SCTP_CONNECTIONS;
862 update_smallest_pmtu_idx (sctp_connection_t * sctp_conn)
865 u8 smallest_pmtu_index = MAIN_SCTP_SUB_CONN_IDX;
867 for (i = 1; i < MAX_SCTP_CONNECTIONS; i++)
869 if (sctp_conn->sub_conn[i].state != SCTP_SUBCONN_STATE_DOWN)
871 if (sctp_conn->sub_conn[i].PMTU <
872 sctp_conn->sub_conn[smallest_pmtu_index].PMTU)
873 smallest_pmtu_index = i;
877 sctp_conn->smallest_PMTU_idx = smallest_pmtu_index;
880 /* As per RFC4960; section 7.2.1: Slow-Start */
882 sctp_init_cwnd (sctp_connection_t * sctp_conn)
885 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
887 /* Section 7.2.1; point (1) */
888 sctp_conn->sub_conn[i].cwnd =
889 clib_min (4 * sctp_conn->sub_conn[i].PMTU,
890 clib_max (2 * sctp_conn->sub_conn[i].PMTU, 4380));
892 /* Section 7.2.1; point (3) */
893 sctp_conn->sub_conn[i].ssthresh = SCTP_INITIAL_SSHTRESH;
895 /* Section 7.2.2; point (1) */
896 sctp_conn->sub_conn[i].partially_acked_bytes = 0;
901 sctp_in_cong_recovery (sctp_connection_t * sctp_conn, u8 idx)
907 cwnd_fully_utilized (sctp_connection_t * sctp_conn, u8 idx)
912 /* As per RFC4960; section 7.2.1: Slow-Start */
914 update_cwnd (sctp_connection_t * sctp_conn)
918 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
920 /* Section 7.2.1; point (2) */
921 if (sctp_conn->sub_conn[i].is_retransmitting)
923 sctp_conn->sub_conn[i].cwnd = 1 * sctp_conn->sub_conn[i].PMTU;
927 /* Section 7.2.2; point (4) */
928 if (sctp_conn->sub_conn[i].last_data_ts >
929 sctp_time_now () + SCTP_DATA_IDLE_INTERVAL)
931 sctp_conn->sub_conn[i].cwnd =
932 clib_max (sctp_conn->sub_conn[i].cwnd / 2,
933 4 * sctp_conn->sub_conn[i].PMTU);
937 /* Section 7.2.1; point (5) */
938 if (sctp_conn->sub_conn[i].cwnd <= sctp_conn->sub_conn[i].ssthresh)
940 if (!cwnd_fully_utilized (sctp_conn, i))
943 if (sctp_in_cong_recovery (sctp_conn, i))
946 sctp_conn->sub_conn[i].cwnd =
947 clib_min (sctp_conn->sub_conn[i].PMTU, 1);
953 * fd.io coding-style-patch-verification: ON
956 * eval: (c-set-style "gnu")