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 #include <vnet/sctp/sctp.h>
16 #include <vnet/sctp/sctp_debug.h>
18 sctp_main_t sctp_main;
21 sctp_connection_bind (u32 session_index, transport_endpoint_t * tep)
23 sctp_main_t *tm = &sctp_main;
24 sctp_connection_t *listener;
27 pool_get (tm->listener_pool, listener);
28 memset (listener, 0, sizeof (*listener));
30 listener->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
31 SCTP_PRIMARY_PATH_IDX;
32 listener->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
33 listener - tm->listener_pool;
34 listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.lcl_port = tep->port;
36 /* If we are provided a sw_if_index, bind using one of its IPs */
37 if (ip_is_zero (&tep->ip, 1) && tep->sw_if_index != ENDPOINT_INVALID_INDEX)
39 if ((iface_ip = ip_interface_get_first_ip (tep->sw_if_index,
41 ip_set (&tep->ip, iface_ip, tep->is_ip4);
43 ip_copy (&listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.lcl_ip,
44 &tep->ip, tep->is_ip4);
46 listener->sub_conn[SCTP_PRIMARY_PATH_IDX].PMTU =
47 vnet_sw_interface_get_mtu (vnet_get_main (), tep->sw_if_index, VLIB_TX);
48 listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.is_ip4 = tep->is_ip4;
49 listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.proto =
51 listener->sub_conn[SCTP_PRIMARY_PATH_IDX].c_s_index = session_index;
52 listener->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.fib_index =
54 listener->state = SCTP_STATE_CLOSED;
56 sctp_connection_timers_init (listener);
58 return listener->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index;
62 sctp_session_bind (u32 session_index, transport_endpoint_t * tep)
64 return sctp_connection_bind (session_index, tep);
68 sctp_connection_unbind (u32 listener_index)
70 sctp_main_t *tm = vnet_get_sctp_main ();
71 sctp_connection_t *sctp_conn;
73 sctp_conn = pool_elt_at_index (tm->listener_pool, listener_index);
75 /* Poison the entry */
77 memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
79 pool_put_index (tm->listener_pool, listener_index);
83 sctp_session_unbind (u32 listener_index)
85 sctp_connection_unbind (listener_index);
90 sctp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add)
92 sctp_main_t *tm = &sctp_main;
94 tm->punt_unknown4 = is_add;
96 tm->punt_unknown6 = is_add;
100 sctp_alloc_custom_local_endpoint (sctp_main_t * tm, ip46_address_t * lcl_addr,
101 u16 * lcl_port, u8 is_ip4)
106 index = tm->last_v4_address_rotor++;
107 if (tm->last_v4_address_rotor >= vec_len (tm->ip4_src_addresses))
108 tm->last_v4_address_rotor = 0;
109 lcl_addr->ip4.as_u32 = tm->ip4_src_addresses[index].as_u32;
113 index = tm->last_v6_address_rotor++;
114 if (tm->last_v6_address_rotor >= vec_len (tm->ip6_src_addresses))
115 tm->last_v6_address_rotor = 0;
116 clib_memcpy (&lcl_addr->ip6, &tm->ip6_src_addresses[index],
117 sizeof (ip6_address_t));
119 port = transport_alloc_local_port (TRANSPORT_PROTO_SCTP, lcl_addr);
122 clib_warning ("Failed to allocate src port");
130 * Initialize all connection timers as invalid
133 sctp_connection_timers_init (sctp_connection_t * sctp_conn)
137 /* Set all to invalid */
138 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
140 sctp_conn->sub_conn[i].RTO = SCTP_RTO_INIT;
142 for (j = 0; j < SCTP_N_TIMERS; j++)
144 sctp_conn->sub_conn[i].timers[j] = SCTP_TIMER_HANDLE_INVALID;
150 * Stop all connection timers
153 sctp_connection_timers_reset (sctp_connection_t * sctp_conn)
156 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
158 for (j = 0; j < SCTP_N_TIMERS; j++)
159 sctp_timer_reset (sctp_conn, i, j);
163 const char *sctp_fsm_states[] = {
164 #define _(sym, str) str,
165 foreach_sctp_fsm_state
170 format_sctp_state (u8 * s, va_list * args)
172 u32 state = va_arg (*args, u32);
174 if (state < SCTP_N_STATES)
175 s = format (s, "%s", sctp_fsm_states[state]);
177 s = format (s, "UNKNOWN (%d (0x%x))", state, state);
182 format_sctp_connection_id (u8 * s, va_list * args)
184 sctp_connection_t *sctp_conn = va_arg (*args, sctp_connection_t *);
189 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
191 if (sctp_conn->sub_conn[i].connection.is_ip4)
193 s = format (s, "%U[#%d][%s] %U:%d->%U:%d",
195 sctp_conn->sub_conn[i].connection.thread_index,
198 &sctp_conn->sub_conn[i].connection.lcl_ip.ip4,
199 clib_net_to_host_u16 (sctp_conn->sub_conn[i].
200 connection.lcl_port),
202 &sctp_conn->sub_conn[i].connection.rmt_ip.ip4,
203 clib_net_to_host_u16 (sctp_conn->sub_conn[i].
204 connection.rmt_port));
208 s = format (s, "%U[#%d][%s] %U:%d->%U:%d",
210 sctp_conn->sub_conn[i].connection.thread_index,
213 &sctp_conn->sub_conn[i].connection.lcl_ip.ip6,
214 clib_net_to_host_u16 (sctp_conn->sub_conn[i].
215 connection.lcl_port),
217 &sctp_conn->sub_conn[i].connection.rmt_ip.ip6,
218 clib_net_to_host_u16 (sctp_conn->sub_conn[i].
219 connection.rmt_port));
226 format_sctp_connection (u8 * s, va_list * args)
228 sctp_connection_t *sctp_conn = va_arg (*args, sctp_connection_t *);
229 u32 verbose = va_arg (*args, u32);
233 s = format (s, "%-50U", format_sctp_connection_id, sctp_conn);
236 s = format (s, "%-15U", format_sctp_state, sctp_conn->state);
243 * Initialize connection send variables.
246 sctp_init_snd_vars (sctp_connection_t * sctp_conn)
250 * We use the time to randomize iss and for setting up the initial
251 * timestamp. Make sure it's updated otherwise syn and ack in the
252 * handshake may make it look as if time has flown in the opposite
256 sctp_set_time_now (vlib_get_thread_index ());
257 time_now = sctp_time_now ();
259 sctp_conn->local_initial_tsn = random_u32 (&time_now);
260 sctp_conn->last_unacked_tsn = sctp_conn->local_initial_tsn;
261 sctp_conn->next_tsn = sctp_conn->local_initial_tsn + 1;
263 sctp_conn->remote_initial_tsn = 0x0;
264 sctp_conn->last_rcvd_tsn = sctp_conn->remote_initial_tsn;
267 always_inline sctp_connection_t *
268 sctp_sub_connection_add (u8 thread_index)
270 sctp_main_t *tm = vnet_get_sctp_main ();
271 sctp_connection_t *sctp_conn = tm->connections[thread_index];
273 u8 subconn_idx = sctp_next_avail_subconn (sctp_conn);
275 ASSERT (subconn_idx < MAX_SCTP_CONNECTIONS);
277 sctp_conn->sub_conn[subconn_idx].connection.c_index =
278 sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.c_index;
279 sctp_conn->sub_conn[subconn_idx].connection.thread_index = thread_index;
280 sctp_conn->sub_conn[subconn_idx].subconn_idx = subconn_idx;
286 sctp_sub_connection_add_ip4 (vlib_main_t * vm,
287 ip4_address_t * lcl_addr,
288 ip4_address_t * rmt_addr)
290 sctp_connection_t *sctp_conn = sctp_sub_connection_add (vm->thread_index);
292 u8 subconn_idx = sctp_next_avail_subconn (sctp_conn);
294 if (subconn_idx == MAX_SCTP_CONNECTIONS)
295 return SCTP_ERROR_MAX_CONNECTIONS;
297 clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.lcl_ip,
298 &lcl_addr, sizeof (lcl_addr));
300 clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.rmt_ip,
301 &rmt_addr, sizeof (rmt_addr));
303 sctp_conn->forming_association_changed = 1;
305 return SCTP_ERROR_NONE;
309 sctp_sub_connection_del_ip4 (ip4_address_t * lcl_addr,
310 ip4_address_t * rmt_addr)
312 sctp_main_t *sctp_main = vnet_get_sctp_main ();
314 u32 thread_idx = vlib_get_thread_index ();
317 ASSERT (thread_idx == 0);
319 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
321 sctp_connection_t *sctp_conn = sctp_main->connections[thread_idx];
322 sctp_sub_connection_t *sub_conn =
323 &sctp_main->connections[thread_idx]->sub_conn[i];
324 ip46_address_t *lcl_ip =
325 &sctp_main->connections[thread_idx]->sub_conn[i].connection.lcl_ip;
326 ip46_address_t *rmt_ip =
327 &sctp_main->connections[thread_idx]->sub_conn[i].connection.rmt_ip;
329 if (!sub_conn->connection.is_ip4)
331 if (lcl_ip->ip4.as_u32 == lcl_addr->as_u32 &&
332 rmt_ip->ip4.as_u32 == rmt_addr->as_u32)
334 sub_conn->state = SCTP_SUBCONN_STATE_DOWN;
335 sctp_conn->forming_association_changed = 1;
339 return SCTP_ERROR_NONE;
343 sctp_sub_connection_add_ip6 (vlib_main_t * vm,
344 ip6_address_t * lcl_addr,
345 ip6_address_t * rmt_addr)
347 sctp_connection_t *sctp_conn = sctp_sub_connection_add (vm->thread_index);
349 u8 subconn_idx = sctp_next_avail_subconn (sctp_conn);
351 if (subconn_idx == MAX_SCTP_CONNECTIONS)
352 return SCTP_ERROR_MAX_CONNECTIONS;
354 clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.lcl_ip,
355 &lcl_addr, sizeof (lcl_addr));
357 clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.rmt_ip,
358 &rmt_addr, sizeof (rmt_addr));
360 sctp_conn->forming_association_changed = 1;
362 return SCTP_ERROR_NONE;
366 sctp_sub_connection_del_ip6 (ip6_address_t * lcl_addr,
367 ip6_address_t * rmt_addr)
369 sctp_main_t *sctp_main = vnet_get_sctp_main ();
371 u32 thread_idx = vlib_get_thread_index ();
374 ASSERT (thread_idx == 0);
376 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
378 sctp_connection_t *sctp_conn = sctp_main->connections[thread_idx];
379 sctp_sub_connection_t *sub_conn =
380 &sctp_main->connections[thread_idx]->sub_conn[i];
381 ip46_address_t *lcl_ip =
382 &sctp_main->connections[thread_idx]->sub_conn[i].connection.lcl_ip;
383 ip46_address_t *rmt_ip =
384 &sctp_main->connections[thread_idx]->sub_conn[i].connection.rmt_ip;
386 if (!sub_conn->connection.is_ip4)
388 if ((lcl_ip->ip6.as_u64[0] == lcl_addr->as_u64[0]
389 && lcl_ip->ip6.as_u64[1] == lcl_addr->as_u64[1])
390 && (rmt_ip->ip6.as_u64[0] == rmt_addr->as_u64[0]
391 && rmt_ip->ip6.as_u64[1] == rmt_addr->as_u64[1]))
393 sub_conn->state = SCTP_SUBCONN_STATE_DOWN;
394 sctp_conn->forming_association_changed = 1;
398 return SCTP_ERROR_NONE;
402 sctp_configure (sctp_user_configuration_t config)
404 sctp_main_t *sctp_main = vnet_get_sctp_main ();
406 u32 thread_idx = vlib_get_thread_index ();
408 sctp_main->connections[thread_idx]->conn_config.never_delay_sack =
409 config.never_delay_sack;
410 sctp_main->connections[thread_idx]->conn_config.never_bundle =
417 sctp_connection_new (u8 thread_index)
419 sctp_main_t *sctp_main = vnet_get_sctp_main ();
420 sctp_connection_t *sctp_conn;
422 pool_get (sctp_main->connections[thread_index], sctp_conn);
423 memset (sctp_conn, 0, sizeof (*sctp_conn));
424 sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
425 SCTP_PRIMARY_PATH_IDX;
426 sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
427 sctp_conn - sctp_main->connections[thread_index];
428 sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_thread_index = thread_index;
429 sctp_conn->local_tag = 0;
435 sctp_half_open_connection_new (u8 thread_index)
437 sctp_main_t *tm = vnet_get_sctp_main ();
438 sctp_connection_t *sctp_conn = 0;
439 ASSERT (vlib_get_thread_index () == 0);
440 pool_get (tm->half_open_connections, sctp_conn);
441 memset (sctp_conn, 0, sizeof (*sctp_conn));
442 sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
443 sctp_conn - tm->half_open_connections;
444 sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
445 SCTP_PRIMARY_PATH_IDX;
450 sctp_connection_open (transport_endpoint_t * rmt)
452 sctp_main_t *tm = vnet_get_sctp_main ();
453 sctp_connection_t *sctp_conn;
454 ip46_address_t lcl_addr;
459 u8 idx = SCTP_PRIMARY_PATH_IDX;
462 * Allocate local endpoint
464 if ((rmt->is_ip4 && vec_len (tm->ip4_src_addresses))
465 || (!rmt->is_ip4 && vec_len (tm->ip6_src_addresses)))
466 rv = sctp_alloc_custom_local_endpoint (tm, &lcl_addr, &lcl_port,
469 rv = transport_alloc_local_endpoint (TRANSPORT_PROTO_SCTP,
470 rmt, &lcl_addr, &lcl_port);
476 * Create connection and send INIT CHUNK
478 thread_id = vlib_get_thread_index ();
479 ASSERT (thread_id == 0);
481 clib_spinlock_lock_if_init (&tm->half_open_lock);
482 sctp_conn = sctp_half_open_connection_new (thread_id);
483 sctp_conn->sub_conn[idx].PMTU =
484 vnet_sw_interface_get_mtu (vnet_get_main (), rmt->sw_if_index, VLIB_TX);
486 transport_connection_t *trans_conn = &sctp_conn->sub_conn[idx].connection;
487 ip_copy (&trans_conn->rmt_ip, &rmt->ip, rmt->is_ip4);
488 ip_copy (&trans_conn->lcl_ip, &lcl_addr, rmt->is_ip4);
489 sctp_conn->sub_conn[idx].subconn_idx = idx;
490 trans_conn->rmt_port = rmt->port;
491 trans_conn->lcl_port = clib_host_to_net_u16 (lcl_port);
492 trans_conn->is_ip4 = rmt->is_ip4;
493 trans_conn->proto = TRANSPORT_PROTO_SCTP;
494 trans_conn->fib_index = rmt->fib_index;
496 sctp_connection_timers_init (sctp_conn);
497 /* The other connection vars will be initialized after INIT_ACK chunk received */
498 sctp_init_snd_vars (sctp_conn);
500 sctp_send_init (sctp_conn);
502 clib_spinlock_unlock_if_init (&tm->half_open_lock);
504 return sctp_conn->sub_conn[idx].connection.c_index;
508 * Cleans up connection state.
513 sctp_connection_cleanup (sctp_connection_t * sctp_conn)
515 sctp_main_t *tm = &sctp_main;
518 /* Cleanup local endpoint if this was an active connect */
519 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
520 transport_endpoint_cleanup (TRANSPORT_PROTO_SCTP,
521 &sctp_conn->sub_conn[i].connection.lcl_ip,
522 sctp_conn->sub_conn[i].connection.lcl_port);
525 sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.thread_index;
527 /* Make sure all timers are cleared */
528 sctp_connection_timers_reset (sctp_conn);
530 /* Poison the entry */
532 memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
533 pool_put (tm->connections[thread_index], sctp_conn);
537 sctp_session_open (transport_endpoint_t * tep)
539 return sctp_connection_open (tep);
543 sctp_check_outstanding_data_chunks (sctp_connection_t * sctp_conn)
546 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
548 if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
551 if (sctp_conn->sub_conn[i].is_retransmitting == 1 ||
552 sctp_conn->sub_conn[i].enqueue_state != SCTP_ERROR_ENQUEUED)
555 ("Connection %u has still DATA to be enqueued inboud / outboud",
556 sctp_conn->sub_conn[i].connection.c_index);
561 return 0; /* Indicates no more data to be read/sent */
565 sctp_connection_close (sctp_connection_t * sctp_conn)
567 SCTP_DBG ("Closing connection %u...",
568 sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection.c_index);
570 sctp_conn->state = SCTP_STATE_SHUTDOWN_PENDING;
572 sctp_send_shutdown (sctp_conn);
576 sctp_session_close (u32 conn_index, u32 thread_index)
578 ASSERT (thread_index == 0);
580 sctp_connection_t *sctp_conn =
581 sctp_connection_get (conn_index, thread_index);
582 if (sctp_conn != NULL)
583 sctp_connection_close (sctp_conn);
587 sctp_session_cleanup (u32 conn_index, u32 thread_index)
589 sctp_connection_t *sctp_conn =
590 sctp_connection_get (conn_index, thread_index);
592 if (sctp_conn != NULL)
594 sctp_connection_timers_reset (sctp_conn);
595 /* Wait for the session tx events to clear */
596 sctp_conn->state = SCTP_STATE_CLOSED;
601 * Compute maximum segment size for session layer.
604 sctp_session_send_mss (transport_connection_t * trans_conn)
606 sctp_connection_t *sctp_conn =
607 sctp_get_connection_from_transport (trans_conn);
609 if (sctp_conn == NULL)
611 SCTP_DBG ("sctp_conn == NULL");
615 update_cwnd (sctp_conn);
616 update_smallest_pmtu_idx (sctp_conn);
618 u8 idx = sctp_data_subconn_select (sctp_conn);
620 return sctp_conn->sub_conn[idx].cwnd;
624 sctp_snd_space (sctp_connection_t * sctp_conn)
626 /* RFC 4096 Section 6.1; point (A) */
627 if (sctp_conn->peer_rwnd == 0)
630 u8 idx = sctp_data_subconn_select (sctp_conn);
631 /* Finally, let's subtract the DATA chunk headers overhead */
632 return sctp_conn->sub_conn[idx].cwnd -
633 sizeof (sctp_payload_data_chunk_t) - sizeof (sctp_full_hdr_t);
637 * Compute TX window session is allowed to fill.
640 sctp_session_send_space (transport_connection_t * trans_conn)
642 sctp_connection_t *sctp_conn =
643 sctp_get_connection_from_transport (trans_conn);
645 return sctp_snd_space (sctp_conn);
648 transport_connection_t *
649 sctp_session_get_transport (u32 conn_index, u32 thread_index)
651 sctp_connection_t *sctp_conn =
652 sctp_connection_get (conn_index, thread_index);
654 if (PREDICT_TRUE (sctp_conn != NULL))
655 return &sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection;
660 transport_connection_t *
661 sctp_session_get_listener (u32 listener_index)
663 sctp_main_t *tm = vnet_get_sctp_main ();
664 sctp_connection_t *sctp_conn;
665 sctp_conn = pool_elt_at_index (tm->listener_pool, listener_index);
666 return &sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection;
670 format_sctp_session (u8 * s, va_list * args)
672 u32 tci = va_arg (*args, u32);
673 u32 thread_index = va_arg (*args, u32);
674 u32 verbose = va_arg (*args, u32);
675 sctp_connection_t *tc;
677 tc = sctp_connection_get (tci, thread_index);
679 s = format (s, "%U", format_sctp_connection, tc, verbose);
681 s = format (s, "empty\n");
686 format_sctp_listener_session (u8 * s, va_list * args)
688 u32 tci = va_arg (*args, u32);
689 sctp_connection_t *tc = sctp_listener_get (tci);
690 return format (s, "%U", format_sctp_connection_id, tc);
694 sctp_expired_timers_cb (u32 conn_index, u32 timer_id)
696 sctp_connection_t *sctp_conn;
698 sctp_conn = sctp_connection_get (conn_index, vlib_get_thread_index ());
699 /* note: the connection may have already disappeared */
700 if (PREDICT_FALSE (sctp_conn == 0))
703 SCTP_DBG ("%s expired", sctp_timer_to_string (timer_id));
705 if (sctp_conn->sub_conn[conn_index].unacknowledged_hb >
706 SCTP_PATH_MAX_RETRANS)
708 // The remote-peer is considered to be unreachable hence shutting down
709 u8 i, total_subs_down = 1;
710 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
712 if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
715 u32 now = sctp_time_now ();
716 if (now > (sctp_conn->sub_conn[i].last_seen + SCTP_HB_INTERVAL))
718 total_subs_down += 1;
719 sctp_conn->sub_conn[i].state = SCTP_SUBCONN_STATE_DOWN;
723 if (total_subs_down == MAX_SCTP_CONNECTIONS)
725 /* Start cleanup. App wasn't notified yet so use delete notify as
726 * opposed to delete to cleanup session layer state. */
727 stream_session_delete_notify (&sctp_conn->sub_conn
728 [SCTP_PRIMARY_PATH_IDX].connection);
730 sctp_connection_timers_reset (sctp_conn);
732 sctp_connection_cleanup (sctp_conn);
739 case SCTP_TIMER_T1_INIT:
740 sctp_send_init (sctp_conn);
742 case SCTP_TIMER_T1_COOKIE:
743 sctp_send_cookie_echo (sctp_conn);
745 case SCTP_TIMER_T2_SHUTDOWN:
746 sctp_send_shutdown (sctp_conn);
748 case SCTP_TIMER_T3_RXTX:
749 sctp_timer_reset (sctp_conn, conn_index, timer_id);
750 sctp_data_retransmit (sctp_conn);
752 case SCTP_TIMER_T4_HEARTBEAT:
753 sctp_timer_reset (sctp_conn, conn_index, timer_id);
759 sctp_send_heartbeat (sctp_conn);
763 sctp_expired_timers_dispatch (u32 * expired_timers)
766 u32 connection_index, timer_id;
768 for (i = 0; i < vec_len (expired_timers); i++)
770 /* Get session index and timer id */
771 connection_index = expired_timers[i] & 0x0FFFFFFF;
772 timer_id = expired_timers[i] >> 28;
774 SCTP_DBG ("Expired timer ID: %u", timer_id);
776 /* Handle expiration */
777 sctp_expired_timers_cb (connection_index, timer_id);
782 sctp_initialize_timer_wheels (sctp_main_t * tm)
784 tw_timer_wheel_16t_2w_512sl_t *tw;
786 foreach_vlib_main (({
787 tw = &tm->timer_wheels[ii];
788 tw_timer_wheel_init_16t_2w_512sl (tw, sctp_expired_timers_dispatch,
789 100e-3 /* timer period 100ms */ , ~0);
790 tw->last_run_time = vlib_time_now (this_vlib_main);
796 sctp_main_enable (vlib_main_t * vm)
798 sctp_main_t *tm = vnet_get_sctp_main ();
799 vlib_thread_main_t *vtm = vlib_get_thread_main ();
800 clib_error_t *error = 0;
803 sctp_connection_t *sctp_conn __attribute__ ((unused));
804 u32 preallocated_connections_per_thread;
806 if ((error = vlib_call_init_function (vm, ip_main_init)))
808 if ((error = vlib_call_init_function (vm, ip4_lookup_init)))
810 if ((error = vlib_call_init_function (vm, ip6_lookup_init)))
817 ip4_register_protocol (IP_PROTOCOL_SCTP, sctp4_input_node.index);
818 ip6_register_protocol (IP_PROTOCOL_SCTP, sctp6_input_node.index);
821 * Initialize data structures
824 num_threads = 1 /* main thread */ + vtm->n_threads;
825 vec_validate (tm->connections, num_threads - 1);
828 * Preallocate connections. Assume that thread 0 won't
829 * use preallocated threads when running multi-core
831 if (num_threads == 1)
834 preallocated_connections_per_thread = tm->preallocated_connections;
839 preallocated_connections_per_thread =
840 tm->preallocated_connections / (num_threads - 1);
842 for (; thread < num_threads; thread++)
844 if (preallocated_connections_per_thread)
845 pool_init_fixed (tm->connections[thread],
846 preallocated_connections_per_thread);
849 /* Initialize per worker thread tx buffers (used for control messages) */
850 vec_validate (tm->tx_buffers, num_threads - 1);
852 /* Initialize timer wheels */
853 vec_validate (tm->timer_wheels, num_threads - 1);
854 sctp_initialize_timer_wheels (tm);
856 /* Initialize clocks per tick for SCTP timestamp. Used to compute
857 * monotonically increasing timestamps. */
858 tm->tstamp_ticks_per_clock = vm->clib_time.seconds_per_clock
859 / SCTP_TSTAMP_RESOLUTION;
863 clib_spinlock_init (&tm->half_open_lock);
866 vec_validate (tm->tx_frames[0], num_threads - 1);
867 vec_validate (tm->tx_frames[1], num_threads - 1);
868 vec_validate (tm->ip_lookup_tx_frames[0], num_threads - 1);
869 vec_validate (tm->ip_lookup_tx_frames[1], num_threads - 1);
871 tm->bytes_per_buffer = vlib_buffer_free_list_buffer_size
872 (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
874 vec_validate (tm->time_now, num_threads - 1);
879 sctp_enable_disable (vlib_main_t * vm, u8 is_en)
883 if (sctp_main.is_enabled)
886 return sctp_main_enable (vm);
890 sctp_main.is_enabled = 0;
896 transport_connection_t *
897 sctp_half_open_session_get_transport (u32 conn_index)
899 sctp_connection_t *sctp_conn = sctp_half_open_connection_get (conn_index);
900 return &sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].connection;
904 format_sctp_half_open (u8 * s, va_list * args)
906 u32 tci = va_arg (*args, u32);
907 sctp_connection_t *sctp_conn = sctp_half_open_connection_get (tci);
908 return format (s, "%U", format_sctp_connection_id, sctp_conn);
912 sctp_update_time (f64 now, u8 thread_index)
914 sctp_set_time_now (thread_index);
915 tw_timer_expire_timers_16t_2w_512sl (&sctp_main.timer_wheels[thread_index],
917 sctp_flush_frames_to_output (thread_index);
921 const static transport_proto_vft_t sctp_proto = {
922 .enable = sctp_enable_disable,
923 .bind = sctp_session_bind,
924 .unbind = sctp_session_unbind,
925 .open = sctp_session_open,
926 .close = sctp_session_close,
927 .cleanup = sctp_session_cleanup,
928 .push_header = sctp_push_header,
929 .send_mss = sctp_session_send_mss,
930 .send_space = sctp_session_send_space,
931 .update_time = sctp_update_time,
932 .get_connection = sctp_session_get_transport,
933 .get_listener = sctp_session_get_listener,
934 .get_half_open = sctp_half_open_session_get_transport,
935 .format_connection = format_sctp_session,
936 .format_listener = format_sctp_listener_session,
937 .format_half_open = format_sctp_half_open,
938 .tx_type = TRANSPORT_TX_DEQUEUE,
939 .service_type = TRANSPORT_SERVICE_VC,
945 sctp_init (vlib_main_t * vm)
947 sctp_main_t *tm = vnet_get_sctp_main ();
948 ip_main_t *im = &ip_main;
949 ip_protocol_info_t *pi;
950 /* Session layer, and by implication SCTP, are disabled by default */
953 /* Register with IP for header parsing */
954 pi = ip_get_protocol_info (im, IP_PROTOCOL_SCTP);
956 return clib_error_return (0, "SCTP protocol info AWOL");
957 pi->format_header = format_sctp_header;
958 pi->unformat_pg_edit = unformat_pg_sctp_header;
960 /* Register as transport with session layer */
961 transport_register_protocol (TRANSPORT_PROTO_SCTP, &sctp_proto,
962 FIB_PROTOCOL_IP4, sctp4_output_node.index);
963 transport_register_protocol (TRANSPORT_PROTO_SCTP, &sctp_proto,
964 FIB_PROTOCOL_IP6, sctp6_output_node.index);
966 sctp_api_reference ();
971 VLIB_INIT_FUNCTION (sctp_init);
974 * fd.io coding-style-patch-verification: ON
977 * eval: (c-set-style "gnu")