X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsctp%2Fsctp.c;h=cc70f7ccd8de58758c126fcdeb87efdf8c8c100d;hb=465c087;hp=d0f37f4346e13545be9c42ec031d0a38737db03f;hpb=8ad6a2dfed0a7248be9d005dd04c76da142f2238;p=vpp.git diff --git a/src/vnet/sctp/sctp.c b/src/vnet/sctp/sctp.c index d0f37f4346e..cc70f7ccd8d 100644 --- a/src/vnet/sctp/sctp.c +++ b/src/vnet/sctp/sctp.c @@ -27,7 +27,8 @@ sctp_connection_bind (u32 session_index, transport_endpoint_t * tep) pool_get (tm->listener_pool, listener); memset (listener, 0, sizeof (*listener)); - listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = listener; + listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].subconn_idx = + MAIN_SCTP_SUB_CONN_IDX; listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index = listener - tm->listener_pool; listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.lcl_port = tep->port; @@ -42,6 +43,8 @@ sctp_connection_bind (u32 session_index, transport_endpoint_t * tep) ip_copy (&listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.lcl_ip, &tep->ip, tep->is_ip4); + listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].PMTU = + vnet_sw_interface_get_mtu (vnet_get_main (), tep->sw_if_index, VLIB_TX); listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.is_ip4 = tep->is_ip4; listener->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.proto = TRANSPORT_PROTO_SCTP; @@ -135,6 +138,7 @@ sctp_connection_timers_init (sctp_connection_t * sctp_conn) for (i = 0; i < MAX_SCTP_CONNECTIONS; i++) { sctp_conn->sub_conn[i].RTO = SCTP_RTO_INIT; + for (j = 0; j < SCTP_N_TIMERS; j++) { sctp_conn->sub_conn[i].timers[j] = SCTP_TIMER_HANDLE_INVALID; @@ -177,25 +181,44 @@ format_sctp_state (u8 * s, va_list * args) u8 * format_sctp_connection_id (u8 * s, va_list * args) { - /* - sctp_connection_t *sctp_conn = va_arg (*args, sctp_connection_t *); - if (!sctp_conn) - return s; - if (sctp_conn->c_is_ip4) - { - s = format (s, "[#%d][%s] %U:%d->%U:%d", sctp_conn->c_thread_index, "T", - format_ip4_address, &sctp_conn->c_lcl_ip4, - clib_net_to_host_u16 (sctp_conn->c_lcl_port), format_ip4_address, - &sctp_conn->c_rmt_ip4, clib_net_to_host_u16 (sctp_conn->c_rmt_port)); - } - else - { - s = format (s, "[#%d][%s] %U:%d->%U:%d", sctp_conn->c_thread_index, "T", - format_ip6_address, &sctp_conn->c_lcl_ip6, - clib_net_to_host_u16 (sctp_conn->c_lcl_port), format_ip6_address, - &sctp_conn->c_rmt_ip6, clib_net_to_host_u16 (sctp_conn->c_rmt_port)); - } - */ + sctp_connection_t *sctp_conn = va_arg (*args, sctp_connection_t *); + if (!sctp_conn) + return s; + + u8 i; + for (i = 0; i < MAX_SCTP_CONNECTIONS; i++) + { + if (sctp_conn->sub_conn[i].connection.is_ip4) + { + s = format (s, "%U[#%d][%s] %U:%d->%U:%d", + s, + sctp_conn->sub_conn[i].connection.thread_index, + "T", + format_ip4_address, + &sctp_conn->sub_conn[i].connection.lcl_ip.ip4, + clib_net_to_host_u16 (sctp_conn->sub_conn[i]. + connection.lcl_port), + format_ip4_address, + &sctp_conn->sub_conn[i].connection.rmt_ip.ip4, + clib_net_to_host_u16 (sctp_conn->sub_conn[i]. + connection.rmt_port)); + } + else + { + s = format (s, "%U[#%d][%s] %U:%d->%U:%d", + s, + sctp_conn->sub_conn[i].connection.thread_index, + "T", + format_ip6_address, + &sctp_conn->sub_conn[i].connection.lcl_ip.ip6, + clib_net_to_host_u16 (sctp_conn->sub_conn[i]. + connection.lcl_port), + format_ip6_address, + &sctp_conn->sub_conn[i].connection.rmt_ip.ip6, + clib_net_to_host_u16 (sctp_conn->sub_conn[i]. + connection.rmt_port)); + } + } return s; } @@ -234,103 +257,161 @@ sctp_init_snd_vars (sctp_connection_t * sctp_conn) time_now = sctp_time_now (); sctp_conn->local_initial_tsn = random_u32 (&time_now); + sctp_conn->last_unacked_tsn = sctp_conn->local_initial_tsn; + sctp_conn->next_tsn = sctp_conn->local_initial_tsn + 1; + sctp_conn->remote_initial_tsn = 0x0; sctp_conn->last_rcvd_tsn = sctp_conn->remote_initial_tsn; - sctp_conn->next_tsn = sctp_conn->local_initial_tsn + 1; } -/** - * Update max segment size we're able to process. - * - * The value is constrained by our interface's MTU and IP options. It is - * also what we advertise to our peer. - */ -void -sctp_update_rcv_mss (sctp_connection_t * sctp_conn) +always_inline sctp_connection_t * +sctp_sub_connection_add (u8 thread_index) { - sctp_conn->smallest_PMTU = DEFAULT_A_RWND; /* TODO find our iface MTU */ - sctp_conn->a_rwnd = DEFAULT_A_RWND - sizeof (sctp_full_hdr_t); - sctp_conn->rcv_opts.a_rwnd = sctp_conn->a_rwnd; - sctp_conn->rcv_a_rwnd = sctp_conn->a_rwnd; /* This will be updated by our congestion algos */ + sctp_main_t *tm = vnet_get_sctp_main (); + sctp_connection_t *sctp_conn = tm->connections[thread_index]; + + u8 subconn_idx = sctp_next_avail_subconn (sctp_conn); + + ASSERT (subconn_idx < MAX_SCTP_CONNECTIONS); + + sctp_conn->sub_conn[subconn_idx].connection.c_index = + sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index; + sctp_conn->sub_conn[subconn_idx].connection.thread_index = thread_index; + sctp_conn->sub_conn[subconn_idx].subconn_idx = subconn_idx; + + return sctp_conn; } -void -sctp_init_mss (sctp_connection_t * sctp_conn) +u8 +sctp_sub_connection_add_ip4 (vlib_main_t * vm, + ip4_address_t * lcl_addr, + ip4_address_t * rmt_addr) { - SCTP_DBG ("CONN_INDEX = %u", - sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index); + sctp_connection_t *sctp_conn = sctp_sub_connection_add (vm->thread_index); - u16 default_a_rwnd = 536; - sctp_update_rcv_mss (sctp_conn); + u8 subconn_idx = sctp_next_avail_subconn (sctp_conn); - /* TODO cache mss and consider PMTU discovery */ - sctp_conn->snd_a_rwnd = - clib_min (sctp_conn->rcv_opts.a_rwnd, sctp_conn->a_rwnd); + if (subconn_idx == MAX_SCTP_CONNECTIONS) + return SCTP_ERROR_MAX_CONNECTIONS; - if (sctp_conn->snd_a_rwnd < sizeof (sctp_full_hdr_t)) - { - SCTP_ADV_DBG ("sctp_conn->snd_a_rwnd < sizeof(sctp_full_hdr_t)"); - /* Assume that at least the min default mss works */ - sctp_conn->snd_a_rwnd = default_a_rwnd; - sctp_conn->rcv_opts.a_rwnd = default_a_rwnd; - } + clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.lcl_ip, + &lcl_addr, sizeof (lcl_addr)); + + clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.rmt_ip, + &rmt_addr, sizeof (rmt_addr)); - ASSERT (sctp_conn->snd_a_rwnd > sizeof (sctp_full_hdr_t)); + sctp_conn->forming_association_changed = 1; + + return SCTP_ERROR_NONE; } -always_inline sctp_connection_t * -sctp_sub_connection_add (u8 thread_index) +u8 +sctp_sub_connection_del_ip4 (ip4_address_t * lcl_addr, + ip4_address_t * rmt_addr) { - sctp_main_t *tm = vnet_get_sctp_main (); - sctp_connection_t *sctp_conn = tm->connections[thread_index]; + sctp_main_t *sctp_main = vnet_get_sctp_main (); - sctp_conn->sub_conn[sctp_conn->next_avail_sub_conn].connection.c_index = - sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.c_index; - sctp_conn->sub_conn[sctp_conn->next_avail_sub_conn]. - connection.thread_index = thread_index; - sctp_conn->sub_conn[sctp_conn->next_avail_sub_conn].parent = sctp_conn; + u32 thread_idx = vlib_get_thread_index (); + u8 i; - sctp_conn->next_avail_sub_conn += 1; + ASSERT (thread_idx == 0); - return sctp_conn; + for (i = 0; i < MAX_SCTP_CONNECTIONS; i++) + { + sctp_connection_t *sctp_conn = sctp_main->connections[thread_idx]; + sctp_sub_connection_t *sub_conn = + &sctp_main->connections[thread_idx]->sub_conn[i]; + ip46_address_t *lcl_ip = + &sctp_main->connections[thread_idx]->sub_conn[i].connection.lcl_ip; + ip46_address_t *rmt_ip = + &sctp_main->connections[thread_idx]->sub_conn[i].connection.rmt_ip; + + if (!sub_conn->connection.is_ip4) + continue; + if (lcl_ip->ip4.as_u32 == lcl_addr->as_u32 && + rmt_ip->ip4.as_u32 == rmt_addr->as_u32) + { + sub_conn->state = SCTP_SUBCONN_STATE_DOWN; + sctp_conn->forming_association_changed = 1; + break; + } + } + return SCTP_ERROR_NONE; } -void -sctp_sub_connection_add_ip4 (u8 thread_index, - sctp_ipv4_addr_param_t * ipv4_addr) +u8 +sctp_sub_connection_add_ip6 (vlib_main_t * vm, + ip6_address_t * lcl_addr, + ip6_address_t * rmt_addr) { - sctp_connection_t *sctp_conn = sctp_sub_connection_add (thread_index); + sctp_connection_t *sctp_conn = sctp_sub_connection_add (vm->thread_index); + + u8 subconn_idx = sctp_next_avail_subconn (sctp_conn); + + if (subconn_idx == MAX_SCTP_CONNECTIONS) + return SCTP_ERROR_MAX_CONNECTIONS; + + clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.lcl_ip, + &lcl_addr, sizeof (lcl_addr)); - clib_memcpy (&sctp_conn-> - sub_conn[sctp_conn->next_avail_sub_conn].connection.lcl_ip.ip4, - &ipv4_addr->address, sizeof (ipv4_addr->address)); + clib_memcpy (&sctp_conn->sub_conn[subconn_idx].connection.rmt_ip, + &rmt_addr, sizeof (rmt_addr)); + + sctp_conn->forming_association_changed = 1; + + return SCTP_ERROR_NONE; } -void -sctp_sub_connection_add_ip6 (u8 thread_index, - sctp_ipv6_addr_param_t * ipv6_addr) +u8 +sctp_sub_connection_del_ip6 (ip6_address_t * lcl_addr, + ip6_address_t * rmt_addr) { - sctp_connection_t *sctp_conn = sctp_sub_connection_add (thread_index); + sctp_main_t *sctp_main = vnet_get_sctp_main (); + + u32 thread_idx = vlib_get_thread_index (); + u8 i; - clib_memcpy (&sctp_conn-> - sub_conn[sctp_conn->next_avail_sub_conn].connection.lcl_ip.ip6, - &ipv6_addr->address, sizeof (ipv6_addr->address)); + ASSERT (thread_idx == 0); + + for (i = 0; i < MAX_SCTP_CONNECTIONS; i++) + { + sctp_connection_t *sctp_conn = sctp_main->connections[thread_idx]; + sctp_sub_connection_t *sub_conn = + &sctp_main->connections[thread_idx]->sub_conn[i]; + ip46_address_t *lcl_ip = + &sctp_main->connections[thread_idx]->sub_conn[i].connection.lcl_ip; + ip46_address_t *rmt_ip = + &sctp_main->connections[thread_idx]->sub_conn[i].connection.rmt_ip; + + if (!sub_conn->connection.is_ip4) + continue; + if ((lcl_ip->ip6.as_u64[0] == lcl_addr->as_u64[0] + && lcl_ip->ip6.as_u64[1] == lcl_addr->as_u64[1]) + && (rmt_ip->ip6.as_u64[0] == rmt_addr->as_u64[0] + && rmt_ip->ip6.as_u64[1] == rmt_addr->as_u64[1])) + { + sub_conn->state = SCTP_SUBCONN_STATE_DOWN; + sctp_conn->forming_association_changed = 1; + break; + } + } + return SCTP_ERROR_NONE; } sctp_connection_t * sctp_connection_new (u8 thread_index) { - sctp_main_t *tm = vnet_get_sctp_main (); + sctp_main_t *sctp_main = vnet_get_sctp_main (); sctp_connection_t *sctp_conn; - pool_get (tm->connections[thread_index], sctp_conn); + pool_get (sctp_main->connections[thread_index], sctp_conn); memset (sctp_conn, 0, sizeof (*sctp_conn)); - sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = sctp_conn; + sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].subconn_idx = + MAIN_SCTP_SUB_CONN_IDX; sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index = - sctp_conn - tm->connections[thread_index]; + sctp_conn - sctp_main->connections[thread_index]; sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_thread_index = thread_index; sctp_conn->local_tag = 0; - sctp_conn->next_avail_sub_conn = 1; return sctp_conn; } @@ -345,7 +426,8 @@ sctp_half_open_connection_new (u8 thread_index) memset (sctp_conn, 0, sizeof (*sctp_conn)); sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index = sctp_conn - tm->half_open_connections; - sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].parent = sctp_conn; + sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].subconn_idx = + MAIN_SCTP_SUB_CONN_IDX; return sctp_conn; } @@ -359,7 +441,7 @@ sctp_connection_open (transport_endpoint_t * rmt) uword thread_id; int rv; - u8 idx = sctp_pick_conn_idx_on_state (SCTP_STATE_CLOSED); + u8 idx = MAIN_SCTP_SUB_CONN_IDX; /* * Allocate local endpoint @@ -383,11 +465,13 @@ sctp_connection_open (transport_endpoint_t * rmt) clib_spinlock_lock_if_init (&tm->half_open_lock); sctp_conn = sctp_half_open_connection_new (thread_id); + sctp_conn->sub_conn[idx].PMTU = + vnet_sw_interface_get_mtu (vnet_get_main (), rmt->sw_if_index, VLIB_TX); transport_connection_t *trans_conn = &sctp_conn->sub_conn[idx].connection; ip_copy (&trans_conn->rmt_ip, &rmt->ip, rmt->is_ip4); ip_copy (&trans_conn->lcl_ip, &lcl_addr, rmt->is_ip4); - sctp_conn->sub_conn[idx].parent = sctp_conn; + sctp_conn->sub_conn[idx].subconn_idx = idx; trans_conn->rmt_port = rmt->port; trans_conn->lcl_port = clib_host_to_net_u16 (lcl_port); trans_conn->is_ip4 = rmt->is_ip4; @@ -422,24 +506,16 @@ sctp_connection_cleanup (sctp_connection_t * sctp_conn) &sctp_conn->sub_conn[i].connection.lcl_ip, sctp_conn->sub_conn[i].connection.lcl_port); - /* Check if connection is not yet fully established */ - if (sctp_conn->state == SCTP_STATE_COOKIE_WAIT) - { + int thread_index = + sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.thread_index; - } - else - { - int thread_index = - sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection.thread_index; - - /* Make sure all timers are cleared */ - sctp_connection_timers_reset (sctp_conn); + /* Make sure all timers are cleared */ + sctp_connection_timers_reset (sctp_conn); - /* Poison the entry */ - if (CLIB_DEBUG > 0) - memset (sctp_conn, 0xFA, sizeof (*sctp_conn)); - pool_put (tm->connections[thread_index], sctp_conn); - } + /* Poison the entry */ + if (CLIB_DEBUG > 0) + memset (sctp_conn, 0xFA, sizeof (*sctp_conn)); + pool_put (tm->connections[thread_index], sctp_conn); } int @@ -451,6 +527,22 @@ sctp_session_open (transport_endpoint_t * tep) u16 sctp_check_outstanding_data_chunks (sctp_connection_t * sctp_conn) { + u8 i; + for (i = 0; i < MAX_SCTP_CONNECTIONS; i++) + { + if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN) + continue; + + if (sctp_conn->sub_conn[i].is_retransmitting == 1 || + sctp_conn->sub_conn[i].enqueue_state != SCTP_ERROR_ENQUEUED) + { + SCTP_DBG_OUTPUT + ("Connection %u has still DATA to be enqueued inboud / outboud", + sctp_conn->sub_conn[i].connection.c_index); + return 1; + } + + } return 0; /* Indicates no more data to be read/sent */ } @@ -470,97 +562,61 @@ sctp_session_close (u32 conn_index, u32 thread_index) { ASSERT (thread_index == 0); - sctp_connection_t *sctp_conn; - sctp_conn = sctp_connection_get (conn_index, thread_index); - sctp_connection_close (sctp_conn); + sctp_connection_t *sctp_conn = + sctp_connection_get (conn_index, thread_index); + if (sctp_conn != NULL) + sctp_connection_close (sctp_conn); } void sctp_session_cleanup (u32 conn_index, u32 thread_index) { - sctp_connection_t *sctp_conn; - sctp_conn = sctp_connection_get (conn_index, thread_index); - sctp_connection_timers_reset (sctp_conn); + sctp_connection_t *sctp_conn = + sctp_connection_get (conn_index, thread_index); - /* Wait for the session tx events to clear */ - sctp_conn->state = SCTP_STATE_CLOSED; + if (sctp_conn != NULL) + { + sctp_connection_timers_reset (sctp_conn); + /* Wait for the session tx events to clear */ + sctp_conn->state = SCTP_STATE_CLOSED; + } } /** - * Update snd_mss to reflect the effective segment size that we can send + * Compute maximum segment size for session layer. */ -void -sctp_update_snd_mss (sctp_connection_t * sctp_conn) -{ - /* The overhead for the sctp_header_t and sctp_chunks_common_hdr_t - * (the sum equals to sctp_full_hdr_t) is already taken into account - * for the sctp_conn->a_rwnd computation. - * So let's not account it again here. - */ - sctp_conn->snd_hdr_length = - sizeof (sctp_payload_data_chunk_t) - sizeof (sctp_full_hdr_t); - sctp_conn->snd_a_rwnd = - clib_min (sctp_conn->a_rwnd, - sctp_conn->rcv_opts.a_rwnd) - sctp_conn->snd_hdr_length; - - SCTP_DBG ("sctp_conn->snd_a_rwnd = %u, sctp_conn->snd_hdr_length = %u ", - sctp_conn->snd_a_rwnd, sctp_conn->snd_hdr_length); - - ASSERT (sctp_conn->snd_a_rwnd > 0); -} - u16 sctp_session_send_mss (transport_connection_t * trans_conn) { - SCTP_DBG ("CONN_INDEX: %u", trans_conn->c_index); - sctp_connection_t *sctp_conn = sctp_get_connection_from_transport (trans_conn); - if (trans_conn == NULL) - { - SCTP_DBG ("trans_conn == NULL"); - return 0; - } - if (sctp_conn == NULL) { SCTP_DBG ("sctp_conn == NULL"); return 0; } - /* Ensure snd_mss does accurately reflect the amount of data we can push - * in a segment. This also makes sure that options are updated according to - * the current state of the connection. */ - sctp_update_snd_mss (sctp_conn); - return sctp_conn->snd_a_rwnd; + update_cwnd (sctp_conn); + update_smallest_pmtu_idx (sctp_conn); + + return sctp_conn->sub_conn[sctp_conn->smallest_PMTU_idx].cwnd; } u16 sctp_snd_space (sctp_connection_t * sctp_conn) { - /* TODO: This requires a real implementation */ - if (sctp_conn == NULL) - { - SCTP_DBG ("sctp_conn == NULL"); - return 0; - } - - if (sctp_conn->state != SCTP_STATE_ESTABLISHED) - { - SCTP_DBG_STATE_MACHINE - ("Trying to send DATA while not in SCTP_STATE_ESTABLISHED"); - return 0; - } - - return sctp_conn->snd_a_rwnd; + /* Finally, let's subtract the DATA chunk headers overhead */ + return sctp_conn->sub_conn[sctp_conn->smallest_PMTU_idx].cwnd - + sizeof (sctp_payload_data_chunk_t) - sizeof (sctp_full_hdr_t); } +/** + * Compute TX window session is allowed to fill. + */ u32 sctp_session_send_space (transport_connection_t * trans_conn) { - SCTP_DBG ("CONN_INDEX: %u", trans_conn->c_index); - sctp_connection_t *sctp_conn = sctp_get_connection_from_transport (trans_conn); @@ -572,7 +628,11 @@ sctp_session_get_transport (u32 conn_index, u32 thread_index) { sctp_connection_t *sctp_conn = sctp_connection_get (conn_index, thread_index); - return &sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection; + + if (PREDICT_TRUE (sctp_conn != NULL)) + return &sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection; + + return NULL; } transport_connection_t * @@ -587,52 +647,87 @@ sctp_session_get_listener (u32 listener_index) u8 * format_sctp_session (u8 * s, va_list * args) { - return NULL; + u32 tci = va_arg (*args, u32); + u32 thread_index = va_arg (*args, u32); + u32 verbose = va_arg (*args, u32); + sctp_connection_t *tc; + + tc = sctp_connection_get (tci, thread_index); + if (tc) + s = format (s, "%U", format_sctp_connection, tc, verbose); + else + s = format (s, "empty\n"); + return s; } u8 * format_sctp_listener_session (u8 * s, va_list * args) { - return NULL; + u32 tci = va_arg (*args, u32); + sctp_connection_t *tc = sctp_listener_get (tci); + return format (s, "%U", format_sctp_connection_id, tc); } void -sctp_timer_init_handler (u32 conn_index, u32 timer_id) +sctp_expired_timers_cb (u32 conn_index, u32 timer_id) { sctp_connection_t *sctp_conn; - clib_warning (""); sctp_conn = sctp_connection_get (conn_index, vlib_get_thread_index ()); /* note: the connection may have already disappeared */ if (PREDICT_FALSE (sctp_conn == 0)) return; - ASSERT (sctp_conn->state == SCTP_STATE_COOKIE_ECHOED); + + SCTP_DBG ("%s expired", sctp_timer_to_string (timer_id)); switch (timer_id) { + case SCTP_TIMER_T1_INIT: + case SCTP_TIMER_T1_COOKIE: + case SCTP_TIMER_T2_SHUTDOWN: + case SCTP_TIMER_T3_RXTX: + sctp_timer_reset (sctp_conn, conn_index, timer_id); + break; case SCTP_TIMER_T4_HEARTBEAT: - { - clib_warning ("Heartbeat timeout"); - break; - } + sctp_timer_reset (sctp_conn, conn_index, timer_id); + goto heartbeat; } - /* Start cleanup. App wasn't notified yet so use delete notify as - * opposed to delete to cleanup session layer state. */ - stream_session_delete_notify (&sctp_conn-> - sub_conn[MAIN_SCTP_SUB_CONN_IDX].connection); - sctp_connection_timers_reset (sctp_conn); + if (sctp_conn->sub_conn[conn_index].unacknowledged_hb > + SCTP_PATH_MAX_RETRANS) + { + // The remote-peer is considered to be unreachable hence shutting down + u8 i, total_subs_down = 1; + for (i = 0; i < MAX_SCTP_CONNECTIONS; i++) + { + if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN) + continue; + + u32 now = sctp_time_now (); + if (now > (sctp_conn->sub_conn[i].last_seen + SCTP_HB_INTERVAL)) + { + total_subs_down += 1; + sctp_conn->sub_conn[i].state = SCTP_SUBCONN_STATE_DOWN; + } + } - sctp_connection_cleanup (sctp_conn); -} + if (total_subs_down == MAX_SCTP_CONNECTIONS) + { + /* Start cleanup. App wasn't notified yet so use delete notify as + * opposed to delete to cleanup session layer state. */ + stream_session_delete_notify (&sctp_conn->sub_conn + [MAIN_SCTP_SUB_CONN_IDX].connection); -/* *INDENT OFF* */ -static sctp_timer_expiration_handler - * sctp_timer_expiration_handlers[SCTP_N_TIMERS] = { - sctp_timer_init_handler -}; + sctp_connection_timers_reset (sctp_conn); -/* *INDENT ON* */ + sctp_connection_cleanup (sctp_conn); + } + } + return; + +heartbeat: + sctp_send_heartbeat (sctp_conn); +} static void sctp_expired_timers_dispatch (u32 * expired_timers) @@ -646,12 +741,11 @@ sctp_expired_timers_dispatch (u32 * expired_timers) connection_index = expired_timers[i] & 0x0FFFFFFF; timer_id = expired_timers[i] >> 28; + SCTP_DBG ("Expired timer ID: %u", timer_id); + /* Handle expiration */ - (*sctp_timer_expiration_handlers[timer_id]) (connection_index, - timer_id); + sctp_expired_timers_cb (connection_index, timer_id); } - - clib_warning (""); } void @@ -736,6 +830,7 @@ sctp_main_enable (vlib_main_t * vm) if (num_threads > 1) { + clib_spinlock_init (&tm->half_open_lock); } vec_validate (tm->tx_frames[0], num_threads - 1); @@ -783,6 +878,15 @@ format_sctp_half_open (u8 * s, va_list * args) return format (s, "%U", format_sctp_connection_id, sctp_conn); } +void +sctp_update_time (f64 now, u8 thread_index) +{ + sctp_set_time_now (thread_index); + tw_timer_expire_timers_16t_2w_512sl (&sctp_main.timer_wheels[thread_index], + now); + sctp_flush_frames_to_output (thread_index); +} + /* *INDENT OFF* */ const static transport_proto_vft_t sctp_proto = { .enable = sctp_enable_disable, @@ -794,7 +898,7 @@ const static transport_proto_vft_t sctp_proto = { .push_header = sctp_push_header, .send_mss = sctp_session_send_mss, .send_space = sctp_session_send_space, - .tx_fifo_offset = NULL, //sctp_session_tx_fifo_offset, + .update_time = sctp_update_time, .get_connection = sctp_session_get_transport, .get_listener = sctp_session_get_listener, .get_half_open = sctp_half_open_session_get_transport, @@ -827,6 +931,8 @@ sctp_init (vlib_main_t * vm) transport_register_protocol (TRANSPORT_PROTO_SCTP, &sctp_proto, FIB_PROTOCOL_IP6, sctp6_output_node.index); + sctp_api_reference (); + return 0; }