SCTP_INPUT_N_NEXT
} sctp_input_next_t;
+#ifndef CLIB_MARCH_VARIANT
char *
phase_to_string (u8 phase)
{
}
return NULL;
}
+#endif /* CLIB_MARCH_VARIANT */
#define foreach_sctp4_input_next \
_ (DROP, "error-drop") \
#define sctp_next_drop(is_ip4) (is_ip4 ? SCTP_NEXT_DROP4 \
: SCTP_NEXT_DROP6)
-void
+static void
sctp_set_rx_trace_data (sctp_rx_trace_t * rx_trace,
sctp_connection_t * sctp_conn,
sctp_header_t * sctp_hdr, vlib_buffer_t * b0,
{
if (sctp_conn)
{
- clib_memcpy (&rx_trace->sctp_connection, sctp_conn,
- sizeof (rx_trace->sctp_connection));
+ clib_memcpy_fast (&rx_trace->sctp_connection, sctp_conn,
+ sizeof (rx_trace->sctp_connection));
}
else
{
sctp_hdr = sctp_buffer_hdr (b0);
}
- clib_memcpy (&rx_trace->sctp_header, sctp_hdr,
- sizeof (rx_trace->sctp_header));
+ clib_memcpy_fast (&rx_trace->sctp_header, sctp_hdr,
+ sizeof (rx_trace->sctp_header));
}
always_inline u16
{
sctp_connection_cleanup (sctp_conn);
- stream_session_disconnect_notify (&sctp_conn->
+ session_transport_closing_notify (&sctp_conn->
sub_conn[idx].connection);
}
}
{
sctp_ipv4_addr_param_t *ipv4 =
(sctp_ipv4_addr_param_t *) opt_params_hdr;
- clib_memcpy (&ip4_addr, &ipv4->address,
- sizeof (ip4_address_t));
+ clib_memcpy_fast (&ip4_addr, &ipv4->address,
+ sizeof (ip4_address_t));
if (sctp_sub_connection_add_ip4 (vlib_get_main (),
&sctp_conn->sub_conn
{
sctp_ipv6_addr_param_t *ipv6 =
(sctp_ipv6_addr_param_t *) opt_params_hdr;
- clib_memcpy (&ip6_addr, &ipv6->address,
- sizeof (ip6_address_t));
+ clib_memcpy_fast (&ip6_addr, &ipv6->address,
+ sizeof (ip6_address_t));
if (sctp_sub_connection_add_ip6 (vlib_get_main (),
&sctp_conn->sub_conn
{
sctp_hostname_param_t *hostname_addr =
(sctp_hostname_param_t *) opt_params_hdr;
- clib_memcpy (hostname, hostname_addr->hostname,
- FQDN_MAX_LENGTH);
+ clib_memcpy_fast (hostname, hostname_addr->hostname,
+ FQDN_MAX_LENGTH);
break;
}
case SCTP_SUPPORTED_ADDRESS_TYPES:
sctp_state_cookie_param_t *state_cookie_param =
(sctp_state_cookie_param_t *) opt_params_hdr;
- clib_memcpy (&(sctp_conn->cookie_param), state_cookie_param,
- sizeof (sctp_state_cookie_param_t));
+ clib_memcpy_fast (&(sctp_conn->cookie_param),
+ state_cookie_param,
+ sizeof (sctp_state_cookie_param_t));
break;
}
{
sctp_hostname_param_t *hostname_addr =
(sctp_hostname_param_t *) opt_params_hdr;
- clib_memcpy (hostname, hostname_addr->hostname,
- FQDN_MAX_LENGTH);
+ clib_memcpy_fast (hostname, hostname_addr->hostname,
+ FQDN_MAX_LENGTH);
break;
}
case SCTP_UNRECOGNIZED_TYPE:
sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T4_HEARTBEAT,
sctp_conn->sub_conn[idx].RTO);
- stream_session_accept_notify (&sctp_conn->sub_conn[idx].connection);
+ session_stream_accept_notify (&sctp_conn->sub_conn[idx].connection);
return SCTP_ERROR_NONE;
sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T4_HEARTBEAT,
sctp_conn->sub_conn[idx].RTO);
- stream_session_accept_notify (&sctp_conn->sub_conn[idx].connection);
+ session_stream_accept_notify (&sctp_conn->sub_conn[idx].connection);
return SCTP_ERROR_NONE;
if (error0 == SCTP_ERROR_NONE)
{
pool_get (tm->connections[my_thread_index], new_sctp_conn);
- clib_memcpy (new_sctp_conn, sctp_conn,
- sizeof (*new_sctp_conn));
+ clib_memcpy_fast (new_sctp_conn, sctp_conn,
+ sizeof (*new_sctp_conn));
new_sctp_conn->sub_conn[idx].c_c_index =
new_sctp_conn - tm->connections[my_thread_index];
new_sctp_conn->sub_conn[idx].c_thread_index =
return from_frame->n_vectors;
}
-static uword
-sctp4_rcv_phase (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (sctp4_rcv_phase_node) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return sctp46_rcv_phase_inline (vm, node, from_frame, 1 /* is_ip4 */ );
}
-static uword
-sctp6_rcv_phase (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (sctp6_init_phase_node) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return sctp46_rcv_phase_inline (vm, node, from_frame, 0 /* is_ip4 */ );
}
-u8 *
+static u8 *
format_sctp_rx_trace_short (u8 * s, va_list * args)
{
CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp4_rcv_phase_node) =
{
- .function = sctp4_rcv_phase,
.name = "sctp4-rcv",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (sctp4_rcv_phase_node, sctp4_rcv_phase);
-
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp6_init_phase_node) =
{
- .function = sctp6_rcv_phase,
.name = "sctp6-rcv",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (sctp6_init_phase_node, sctp6_rcv_phase);
-
-vlib_node_registration_t sctp4_shutdown_phase_node;
-vlib_node_registration_t sctp6_shutdown_phase_node;
-
always_inline u16
sctp_handle_shutdown (sctp_header_t * sctp_hdr,
sctp_chunks_common_hdr_t * sctp_chunk_hdr,
sctp_timer_reset (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN);
- stream_session_disconnect_notify (&sctp_conn->sub_conn[idx].connection);
+ session_transport_closing_notify (&sctp_conn->sub_conn[idx].connection);
sctp_conn->state = SCTP_STATE_CLOSED;
vlib_add_trace (vm, node, b0, sizeof (*sctp_trace));
if (sctp_hdr != NULL)
- clib_memcpy (&sctp_trace->sctp_header, sctp_hdr,
- sizeof (sctp_trace->sctp_header));
+ clib_memcpy_fast (&sctp_trace->sctp_header, sctp_hdr,
+ sizeof (sctp_trace->sctp_header));
if (sctp_conn != NULL)
- clib_memcpy (&sctp_trace->sctp_connection, sctp_conn,
- sizeof (sctp_trace->sctp_connection));
+ clib_memcpy_fast (&sctp_trace->sctp_connection, sctp_conn,
+ sizeof (sctp_trace->sctp_connection));
}
b0->error = node->errors[error0];
}
-static uword
-sctp4_shutdown_phase (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (sctp4_shutdown_phase_node) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return sctp46_shutdown_phase_inline (vm, node, from_frame, 1 /* is_ip4 */ );
}
-static uword
-sctp6_shutdown_phase (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (sctp6_shutdown_phase_node) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return sctp46_shutdown_phase_inline (vm, node, from_frame, 1 /* is_ip4 */ );
}
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp4_shutdown_phase_node) =
{
- .function = sctp4_shutdown_phase,
.name = "sctp4-shutdown",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (sctp4_shutdown_phase_node,
- sctp4_shutdown_phase);
-
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp6_shutdown_phase_node) =
{
- .function = sctp6_shutdown_phase,
.name = "sctp6-shutdown",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (sctp6_shutdown_phase_node,
- sctp6_shutdown_phase);
-
-vlib_node_registration_t sctp4_listen_phase_node;
-vlib_node_registration_t sctp6_listen_phase_node;
-
-vlib_node_registration_t sctp4_established_phase_node;
-vlib_node_registration_t sctp6_established_phase_node;
-
always_inline u16
sctp_handle_sack (sctp_selective_ack_chunk_t * sack_chunk,
sctp_connection_t * sctp_conn, u8 idx, vlib_buffer_t * b0,
}
else
{
- clib_memcpy (&child_conn->
- sub_conn[SCTP_PRIMARY_PATH_IDX].c_lcl_ip6,
- &ip6_hdr->dst_address, sizeof (ip6_address_t));
- clib_memcpy (&child_conn->
- sub_conn[SCTP_PRIMARY_PATH_IDX].c_rmt_ip6,
- &ip6_hdr->src_address, sizeof (ip6_address_t));
+ clib_memcpy_fast (&child_conn->
+ sub_conn[SCTP_PRIMARY_PATH_IDX].c_lcl_ip6,
+ &ip6_hdr->dst_address,
+ sizeof (ip6_address_t));
+ clib_memcpy_fast (&child_conn->
+ sub_conn[SCTP_PRIMARY_PATH_IDX].c_rmt_ip6,
+ &ip6_hdr->src_address,
+ sizeof (ip6_address_t));
}
sctp_full_hdr_t *full_hdr = (sctp_full_hdr_t *) sctp_hdr;
if (error0 == SCTP_ERROR_NONE)
{
- if (stream_session_accept
+ if (session_stream_accept
(&child_conn->
sub_conn[SCTP_PRIMARY_PATH_IDX].connection,
sctp_listener->
{
sctp_rx_trace_t *t0 =
vlib_add_trace (vm, node, b0, sizeof (*t0));
- clib_memcpy (&t0->sctp_header, sctp_hdr,
- sizeof (t0->sctp_header));
- clib_memcpy (&t0->sctp_connection, sctp_listener,
- sizeof (t0->sctp_connection));
+ clib_memcpy_fast (&t0->sctp_header, sctp_hdr,
+ sizeof (t0->sctp_header));
+ clib_memcpy_fast (&t0->sctp_connection, sctp_listener,
+ sizeof (t0->sctp_connection));
}
b0->error = node->errors[error0];
return from_frame->n_vectors;
}
-static uword
-sctp4_listen_phase (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (sctp4_listen_phase_node) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return sctp46_listen_process_inline (vm, node, from_frame, 1 /* is_ip4 */ );
}
-static uword
-sctp6_listen_phase (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (sctp6_listen_phase_node) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return sctp46_listen_process_inline (vm, node, from_frame, 0 /* is_ip4 */ );
}
sctp46_established_phase_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
vlib_frame_t * from_frame, int is_ip4)
{
+ sctp_main_t *sm = vnet_get_sctp_main ();
u32 n_left_from, next_index, *from, *to_next;
u32 my_thread_index = vm->thread_index, errors = 0;
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
}
- errors = session_manager_flush_enqueue_events (TRANSPORT_PROTO_SCTP,
- my_thread_index);
+ errors = session_main_flush_enqueue_events (TRANSPORT_PROTO_SCTP,
+ my_thread_index);
- sctp_node_inc_counter (vm, is_ip4, sctp4_established_phase_node.index,
- sctp6_established_phase_node.index,
+ sctp_node_inc_counter (vm, is_ip4, sm->sctp4_established_phase_node_index,
+ sm->sctp6_established_phase_node_index,
SCTP_ERROR_EVENT_FIFO_FULL, errors);
sctp_flush_frame_to_output (vm, my_thread_index, is_ip4);
return from_frame->n_vectors;
}
-static uword
-sctp4_established_phase (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (sctp4_established_phase_node) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return sctp46_established_phase_inline (vm, node, from_frame,
1 /* is_ip4 */ );
}
-static uword
-sctp6_established_phase (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (sctp6_established_phase_node) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return sctp46_established_phase_inline (vm, node, from_frame,
0 /* is_ip4 */ );
}
-u8 *
+static u8 *
format_sctp_rx_trace (u8 * s, va_list * args)
{
CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp4_listen_phase_node) =
{
- .function = sctp4_listen_phase,
.name = "sctp4-listen",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (sctp4_listen_phase_node, sctp4_listen_phase);
-
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp6_listen_phase_node) =
{
- .function = sctp6_listen_phase,
.name = "sctp6-listen",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (sctp6_listen_phase_node, sctp6_listen_phase);
-
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp4_established_phase_node) =
{
- .function = sctp4_established_phase,
.name = "sctp4-established",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (sctp4_established_phase_node,
- sctp4_established_phase);
-
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp6_established_phase_node) =
{
- .function = sctp6_established_phase,
.name = "sctp6-established",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (sctp6_established_phase_node,
- sctp6_established_phase);
-
/*
* This is the function executed first for the SCTP graph.
* It takes care of doing the initial message parsing and
{
u32 n_left_from, next_index, *from, *to_next;
u32 my_thread_index = vm->thread_index;
- u8 is_filtered;
+ u8 result;
sctp_main_t *tm = vnet_get_sctp_main ();
from = vlib_frame_vector_args (from_frame);
sctp_hdr->src_port,
TRANSPORT_PROTO_SCTP,
my_thread_index,
- &is_filtered);
+ &result);
}
else
{
sctp_hdr->src_port,
TRANSPORT_PROTO_SCTP,
my_thread_index,
- &is_filtered);
+ &result);
}
/* Length check */
}
else
{
- if (is_filtered)
+ if (result)
{
next0 = SCTP_INPUT_NEXT_DROP;
- error0 = SCTP_ERROR_FILTERED;
+ error0 = SCTP_ERROR_NONE + result;
}
else if ((is_ip4 && tm->punt_unknown4) ||
(!is_ip4 && tm->punt_unknown6))
return from_frame->n_vectors;
}
-static uword
-sctp4_input_dispatcher (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (sctp4_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return sctp46_input_dispatcher (vm, node, from_frame, 1 /* is_ip4 */ );
}
-static uword
-sctp6_input_dispatcher (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (sctp6_input_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return sctp46_input_dispatcher (vm, node, from_frame, 0 /* is_ip4 */ );
}
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp4_input_node) =
{
- .function = sctp4_input_dispatcher,
.name = "sctp4-input",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (sctp4_input_node, sctp4_input_dispatcher);
-
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp6_input_node) =
{
- .function = sctp6_input_dispatcher,
.name = "sctp6-input",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (sctp6_input_node, sctp6_input_dispatcher);
-
-vlib_node_registration_t sctp4_input_node;
-vlib_node_registration_t sctp6_input_node;
-
+#ifndef CLIB_MARCH_VARIANT
static void
sctp_dispatch_table_init (sctp_main_t * tm)
{
}
VLIB_INIT_FUNCTION (sctp_input_init);
+#endif /* CLIB_MARCH_VARIANT */
/*
* fd.io coding-style-patch-verification: ON