diff options
Diffstat (limited to 'src/vnet')
37 files changed, 2844 insertions, 785 deletions
diff --git a/src/vnet/api_errno.h b/src/vnet/api_errno.h index 22cfaee41d6..eeb727672bf 100644 --- a/src/vnet/api_errno.h +++ b/src/vnet/api_errno.h @@ -104,7 +104,7 @@ _(BFD_EAGAIN, -111, "BFD object cannot be manipulated at this time") \ _(INVALID_GPE_MODE, -112, "Invalid GPE mode") \ _(LISP_GPE_ENTRIES_PRESENT, -113, "LISP GPE entries are present") \ _(ADDRESS_FOUND_FOR_INTERFACE, -114, "Address found for interface") \ -_(SESSION_CONNECT_FAIL, -115, "Session failed to connect") \ +_(SESSION_CONNECT, -115, "Session failed to connect") \ _(ENTRY_ALREADY_EXISTS, -116, "Entry already exists") \ _(SVM_SEGMENT_CREATE_FAIL, -117, "svm segment create fail") \ _(APPLICATION_NOT_ATTACHED, -118, "application not attached") \ @@ -116,7 +116,12 @@ _(SUBIF_DOESNT_EXIST, -123, "Subinterface doesn't exist") \ _(L2_MACS_EVENT_CLINET_PRESENT, -124, "Client already exist for L2 MACs events") \ _(INVALID_QUEUE, -125, "Invalid queue") \ _(UNSUPPORTED, -126, "Unsupported") \ -_(DUPLICATE_IF_ADDRESS, -127, "Address already present on another interface") +_(DUPLICATE_IF_ADDRESS, -127, "Address already present on another interface") \ +_(APP_INVALID_NS, -128, "Invalid application namespace") \ +_(APP_WRONG_NS_SECRET, -129, "Wrong app namespace secret") \ +_(APP_CONNECT_SCOPE, -130, "Connect scope") \ +_(APP_ALREADY_ATTACHED, -131, "App already attached") \ +_(SESSION_REDIRECT, -132, "Redirect failed") \ typedef enum { diff --git a/src/vnet/buffer.h b/src/vnet/buffer.h index e774a084436..7567b875248 100644 --- a/src/vnet/buffer.h +++ b/src/vnet/buffer.h @@ -126,8 +126,14 @@ typedef struct protocol and ports. */ u32 flow_hash; - /* next protocol */ - u32 save_protocol; + union + { + /* next protocol */ + u32 save_protocol; + + /* Hint for transport protocols */ + u32 fib_index; + }; /* Rewrite length */ u32 save_rewrite_length; diff --git a/src/vnet/ip/ip.c b/src/vnet/ip/ip.c new file mode 100644 index 00000000000..caa553dd6d7 --- /dev/null +++ b/src/vnet/ip/ip.c @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <vnet/ip/ip.h> +#include <vnet/fib/fib_table.h> + +u8 +ip_is_zero (ip46_address_t * ip46_address, u8 is_ip4) +{ + if (is_ip4) + return (ip46_address->ip4.as_u32 == 0); + else + return (ip46_address->as_u64[0] == 0 && ip46_address->as_u64[1] == 0); +} + +u8 +ip_is_local_host (ip46_address_t * ip46_address, u8 is_ip4) +{ + if (is_ip4) + return (ip46_address->ip4.as_u8[0] == 127); + else + return (ip46_address->as_u64[0] == 0 && ip46_address->as_u64[1] == 1); +} + +/** + * Checks that an ip is local to the requested fib + */ +u8 +ip_is_local (u32 fib_index, ip46_address_t * ip46_address, u8 is_ip4) +{ + fib_node_index_t fei; + fib_entry_flag_t flags; + fib_prefix_t prefix; + + /* Check if requester is local */ + if (is_ip4) + { + prefix.fp_len = 32; + prefix.fp_proto = FIB_PROTOCOL_IP4; + } + else + { + prefix.fp_len = 128; + prefix.fp_proto = FIB_PROTOCOL_IP6; + } + + clib_memcpy (&prefix.fp_addr, ip46_address, sizeof (ip46_address_t)); + fei = fib_table_lookup (0, &prefix); + flags = fib_entry_get_flags (fei); + + return (flags & FIB_ENTRY_FLAG_LOCAL); +} + +u8 +ip_interface_has_address (u32 sw_if_index, ip46_address_t * ip, u8 is_ip4) +{ + ip_interface_address_t *ia = 0; + + if (is_ip4) + { + ip_lookup_main_t *lm4 = &ip4_main.lookup_main; + ip4_address_t *ip4; + /* *INDENT-OFF* */ + foreach_ip_interface_address (lm4, ia, sw_if_index, 1 /* unnumbered */ , + ({ + ip4 = ip_interface_address_get_address (lm4, ia); + if (ip4_address_compare (ip4, &ip->ip4) == 0) + return 1; + })); + /* *INDENT-ON* */ + } + else + { + ip_lookup_main_t *lm6 = &ip6_main.lookup_main; + ip6_address_t *ip6; + /* *INDENT-OFF* */ + foreach_ip_interface_address (lm6, ia, sw_if_index, 1 /* unnumbered */ , + ({ + ip6 = ip_interface_address_get_address (lm6, ia); + if (ip6_address_compare (ip6, &ip->ip6) == 0) + return 1; + })); + /* *INDENT-ON* */ + } + return 0; +} + +void +ip_copy (ip46_address_t * dst, ip46_address_t * src, u8 is_ip4) +{ + if (is_ip4) + dst->ip4.as_u32 = src->ip4.as_u32; + else + clib_memcpy (&dst->ip6, &src->ip6, sizeof (ip6_address_t)); +} + +void +ip_set (ip46_address_t * dst, void *src, u8 is_ip4) +{ + if (is_ip4) + dst->ip4.as_u32 = ((ip4_address_t *) src)->as_u32; + else + clib_memcpy (&dst->ip6, (ip6_address_t *) src, sizeof (ip6_address_t)); +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/ip/ip.h b/src/vnet/ip/ip.h index 7e26bc6c135..3b3a465d042 100644 --- a/src/vnet/ip/ip.h +++ b/src/vnet/ip/ip.h @@ -192,6 +192,13 @@ void ip_table_delete (fib_protocol_t fproto, u32 table_id, u8 is_api); int ip_table_bind (fib_protocol_t fproto, u32 sw_if_index, u32 table_id, u8 is_api); +u8 ip_is_zero (ip46_address_t * ip46_address, u8 is_ip4); +u8 ip_is_local_host (ip46_address_t * ip46_address, u8 is_ip4); +u8 ip_is_local (u32 fib_index, ip46_address_t * ip46_address, u8 is_ip4); +u8 ip_interface_has_address (u32 sw_if_index, ip46_address_t * ip, u8 is_ip4); +void ip_copy (ip46_address_t * dst, ip46_address_t * src, u8 is_ip4); +void ip_set (ip46_address_t * dst, void *src, u8 is_ip4); + #endif /* included_ip_main_h */ /* diff --git a/src/vnet/ip/ip4_forward.c b/src/vnet/ip/ip4_forward.c index daffae410cc..c2a2f79e02f 100755 --- a/src/vnet/ip/ip4_forward.c +++ b/src/vnet/ip/ip4_forward.c @@ -1606,6 +1606,10 @@ ip4_local_inline (vlib_main_t * vm, (vnet_buffer (p1)->sw_if_index[VLIB_TX] == (u32) ~ 0) ? fib_index1 : vnet_buffer (p1)->sw_if_index[VLIB_TX]; + /* TODO maybe move to lookup? */ + vnet_buffer (p0)->ip.fib_index = fib_index0; + vnet_buffer (p1)->ip.fib_index = fib_index1; + mtrie0 = &ip4_fib_get (fib_index0)->mtrie; mtrie1 = &ip4_fib_get (fib_index1)->mtrie; @@ -1744,6 +1748,7 @@ ip4_local_inline (vlib_main_t * vm, fib_index0 = (vnet_buffer (p0)->sw_if_index[VLIB_TX] == (u32) ~ 0) ? fib_index0 : vnet_buffer (p0)->sw_if_index[VLIB_TX]; + vnet_buffer (p0)->ip.fib_index = fib_index0; mtrie0 = &ip4_fib_get (fib_index0)->mtrie; leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, &ip0->src_address); leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, diff --git a/src/vnet/ip/ip6_forward.c b/src/vnet/ip/ip6_forward.c index f54b433485f..6b89ec38aae 100644 --- a/src/vnet/ip/ip6_forward.c +++ b/src/vnet/ip/ip6_forward.c @@ -1428,6 +1428,24 @@ ip6_local_inline (vlib_main_t * vm, vlib_node_runtime_t * node, ? IP6_ERROR_SRC_LOOKUP_MISS : error1); } + /* TODO maybe move to lookup? */ + vnet_buffer (p0)->ip.fib_index = + vec_elt (im->fib_index_by_sw_if_index, + vnet_buffer (p0)->sw_if_index[VLIB_RX]); + vnet_buffer (p0)->ip.fib_index = + (vnet_buffer (p0)->sw_if_index[VLIB_TX] == + (u32) ~ 0) ? vnet_buffer (p0)->ip. + fib_index : vnet_buffer (p0)->sw_if_index[VLIB_TX]; + + vnet_buffer (p1)->ip.fib_index = + vec_elt (im->fib_index_by_sw_if_index, + vnet_buffer (p1)->sw_if_index[VLIB_RX]); + vnet_buffer (p1)->ip.fib_index = + (vnet_buffer (p1)->sw_if_index[VLIB_TX] == + (u32) ~ 0) ? vnet_buffer (p1)->ip. + fib_index : vnet_buffer (p1)->sw_if_index[VLIB_TX]; + + skip_checks: next0 = lm->local_next_by_ip_protocol[ip0->protocol]; @@ -1538,6 +1556,14 @@ ip6_local_inline (vlib_main_t * vm, vlib_node_runtime_t * node, ? IP6_ERROR_SRC_LOOKUP_MISS : error0); } + vnet_buffer (p0)->ip.fib_index = + vec_elt (im->fib_index_by_sw_if_index, + vnet_buffer (p0)->sw_if_index[VLIB_RX]); + vnet_buffer (p0)->ip.fib_index = + (vnet_buffer (p0)->sw_if_index[VLIB_TX] == + (u32) ~ 0) ? vnet_buffer (p0)->ip. + fib_index : vnet_buffer (p0)->sw_if_index[VLIB_TX]; + skip_check: next0 = lm->local_next_by_ip_protocol[ip0->protocol]; diff --git a/src/vnet/session/application.c b/src/vnet/session/application.c index 2b789c5f420..75d3cfb2e33 100644 --- a/src/vnet/session/application.c +++ b/src/vnet/session/application.c @@ -15,6 +15,7 @@ #include <vnet/session/application.h> #include <vnet/session/application_interface.h> +#include <vnet/session/application_namespace.h> #include <vnet/session/session.h> /** @@ -32,6 +33,46 @@ static uword *app_by_api_client_index; */ static u32 default_app_evt_queue_size = 128; +static u8 * +app_get_name_from_reg_index (application_t * app) +{ + u8 *app_name; + + vl_api_registration_t *regp; + regp = vl_api_client_index_to_registration (app->api_client_index); + if (!regp) + app_name = format (0, "builtin-%d%c", app->index, 0); + else + app_name = format (0, "%s%c", regp->name, 0); + + return app_name; +} + +u32 +application_session_table (application_t * app, u8 fib_proto) +{ + app_namespace_t *app_ns; + app_ns = app_namespace_get (app->ns_index); + if (!application_has_global_scope (app)) + return APP_INVALID_INDEX; + if (fib_proto == FIB_PROTOCOL_IP4) + return session_lookup_get_index_for_fib (fib_proto, + app_ns->ip4_fib_index); + else + return session_lookup_get_index_for_fib (fib_proto, + app_ns->ip6_fib_index); +} + +u32 +application_local_session_table (application_t * app) +{ + app_namespace_t *app_ns; + if (!application_has_local_scope (app)) + return APP_INVALID_INDEX; + app_ns = app_namespace_get (app->ns_index); + return app_ns->local_table_index; +} + int application_api_queue_is_full (application_t * app) { @@ -50,6 +91,21 @@ application_api_queue_is_full (application_t * app) return 0; } +/** + * Returns app name + * + * Since the name is not stored per app, we generate it on the fly. It is + * the caller's responsibility to free the vector + */ +u8 * +application_name_from_index (u32 app_index) +{ + application_t *app = application_get (app_index); + if (!app) + return 0; + return app_get_name_from_reg_index (app); +} + static void application_table_add (application_t * app) { @@ -135,7 +191,6 @@ application_del (application_t * app) segment_manager_init_del (sm); } - /* If first segment manager is used by a listener */ if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX && app->first_segment_manager != app->connects_seg_manager) @@ -180,7 +235,9 @@ application_init (application_t * app, u32 api_client_index, u64 * options, app_evt_queue_size = options[APP_EVT_QUEUE_SIZE] > 0 ? options[APP_EVT_QUEUE_SIZE] : default_app_evt_queue_size; - /* Setup segment manager */ + /* + * Setup segment manager + */ sm = segment_manager_new (); sm->app_index = app->index; props = &app->sm_properties; @@ -203,10 +260,19 @@ application_init (application_t * app, u32 api_client_index, u64 * options, return rv; sm->first_is_protected = 1; + /* + * Setup application + */ app->first_segment_manager = segment_manager_index (sm); app->api_client_index = api_client_index; app->flags = options[APP_OPTIONS_FLAGS]; app->cb_fns = *cb_fns; + app->ns_index = options[APP_OPTIONS_NAMESPACE]; + + /* If no scope enabled, default to global */ + if (!application_has_global_scope (app) + && !application_has_local_scope (app)) + app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; /* Allocate app event queue in the first shared-memory segment */ app->event_queue = segment_manager_alloc_queue (sm, app_evt_queue_size); @@ -223,6 +289,8 @@ application_init (application_t * app, u32 api_client_index, u64 * options, application_t * application_get (u32 index) { + if (index == APP_INVALID_INDEX) + return 0; return pool_elt_at_index (app_pool, index); } @@ -269,17 +337,19 @@ application_alloc_segment_manager (application_t * app) * it's own specific listening connection. */ int -application_start_listen (application_t * srv, session_type_t session_type, - transport_endpoint_t * tep, u64 * res) +application_start_listen (application_t * srv, session_endpoint_t * sep, + u64 * res) { segment_manager_t *sm; stream_session_t *s; u64 handle; + session_type_t sst; - s = listen_session_new (session_type); + sst = session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4); + s = listen_session_new (sst); s->app_index = srv->index; - if (stream_session_listen (s, tep)) + if (stream_session_listen (s, sep)) goto err; /* Allocate segment manager. All sessions derived out of a listen session @@ -341,15 +411,15 @@ application_stop_listen (application_t * srv, u64 handle) } int -application_open_session (application_t * app, session_type_t sst, - transport_endpoint_t * tep, u32 api_context) +application_open_session (application_t * app, session_endpoint_t * sep, + u32 api_context) { segment_manager_t *sm; transport_connection_t *tc = 0; int rv; /* Make sure we have a segment manager for connects */ - if (app->connects_seg_manager == (u32) ~ 0) + if (app->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX) { sm = application_alloc_segment_manager (app); if (sm == 0) @@ -357,7 +427,7 @@ application_open_session (application_t * app, session_type_t sst, app->connects_seg_manager = segment_manager_index (sm); } - if ((rv = stream_session_open (app->index, sst, tep, &tc))) + if ((rv = stream_session_open (app->index, sep, &tc))) return rv; /* Store api_context for when the reply comes. Not the nicest thing @@ -384,21 +454,6 @@ application_get_listen_segment_manager (application_t * app, return segment_manager_get (*smp); } -static u8 * -app_get_name_from_reg_index (application_t * app) -{ - u8 *app_name; - - vl_api_registration_t *regp; - regp = vl_api_client_index_to_registration (app->api_client_index); - if (!regp) - app_name = format (0, "builtin-%d%c", app->index, 0); - else - app_name = format (0, "%s%c", regp->name, 0); - - return app_name; -} - int application_is_proxy (application_t * app) { @@ -420,6 +475,18 @@ application_add_segment_notify (u32 app_index, u32 fifo_segment_index) seg_size); } +u8 +application_has_local_scope (application_t * app) +{ + return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; +} + +u8 +application_has_global_scope (application_t * app) +{ + return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; +} + u8 * format_application_listener (u8 * s, va_list * args) { @@ -500,7 +567,7 @@ application_format_connects (application_t * app, int verbose) session_index = fifo->master_session_index; thread_index = fifo->master_thread_index; - session = stream_session_get (session_index, thread_index); + session = session_get (session_index, thread_index); str = format (0, "%U", format_stream_session, session, verbose); if (verbose) @@ -526,27 +593,33 @@ format_application (u8 * s, va_list * args) { application_t *app = va_arg (*args, application_t *); CLIB_UNUSED (int verbose) = va_arg (*args, int); + const u8 *app_ns_name; u8 *app_name; if (app == 0) { if (verbose) - s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s", "Index", "Name", - "API Client", "Add seg size", "Rx fifo size", + s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name", + "Namespace", "API Client", "Add seg size", "Rx fifo size", "Tx fifo size"); else - s = format (s, "%-10s%-20s%-20s", "Index", "Name", "API Client"); + s = + format (s, "%-10s%-20s%-15s%-20s", "Index", "Name", "Namespace", + "API Client"); return s; } app_name = app_get_name_from_reg_index (app); + app_ns_name = app_namespace_id_from_index (app->ns_index); if (verbose) - s = format (s, "%-10d%-20s%-15d%-15d%-15d%-15d", app->index, app_name, - app->api_client_index, app->sm_properties.add_segment_size, - app->sm_properties.rx_fifo_size, - app->sm_properties.tx_fifo_size); + s = + format (s, "%-10d%-20s%-15s%-15d%-15d%-15d%-15d", app->index, app_name, + app_ns_name, app->api_client_index, + app->sm_properties.add_segment_size, + app->sm_properties.rx_fifo_size, + app->sm_properties.tx_fifo_size); else - s = format (s, "%-10d%-20s%-20d", app->index, app_name, + s = format (s, "%-10d%-20s%-15s%-20d", app->index, app_name, app_ns_name, app->api_client_index); return s; } @@ -560,10 +633,7 @@ show_app_command_fn (vlib_main_t * vm, unformat_input_t * input, int do_client = 0; int verbose = 0; - if (!session_manager_is_enabled ()) - { - clib_error_return (0, "session layer is not enabled"); - } + session_cli_return_if_not_enabled (); while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { @@ -627,13 +697,11 @@ show_app_command_fn (vlib_main_t * vm, unformat_input_t * input, if (!do_server && !do_client) { vlib_cli_output (vm, "%U", format_application, 0, verbose); - pool_foreach (app, app_pool, ( - { - vlib_cli_output (vm, "%U", - format_application, app, - verbose); - } - )); + /* *INDENT-OFF* */ + pool_foreach (app, app_pool, ({ + vlib_cli_output (vm, "%U", format_application, app, verbose); + })); + /* *INDENT-ON* */ } return 0; diff --git a/src/vnet/session/application.h b/src/vnet/session/application.h index e030c376d83..00a5554dd23 100644 --- a/src/vnet/session/application.h +++ b/src/vnet/session/application.h @@ -19,7 +19,7 @@ #include <vnet/vnet.h> #include <vnet/session/session.h> #include <vnet/session/segment_manager.h> - +#include <vnet/session/application_namespace.h> typedef enum { APP_SERVER, @@ -36,7 +36,7 @@ typedef struct _stream_session_cb_vft /** Notify server of newly accepted session */ int (*session_accept_callback) (stream_session_t * new_session); - /* Connection request callback */ + /** Connection request callback */ int (*session_connected_callback) (u32 app_index, u32 opaque, stream_session_t * s, u8 code); @@ -46,10 +46,10 @@ typedef struct _stream_session_cb_vft /** Notify app that session was reset */ void (*session_reset_callback) (stream_session_t * s); - /* Direct RX callback, for built-in servers */ + /** Direct RX callback, for built-in servers */ int (*builtin_server_rx_callback) (stream_session_t * session); - /* Redirect connection to local server */ + /** Redirect connection to local server */ int (*redirect_connect_callback) (u32 api_client_index, void *mp); } session_cb_vft_t; @@ -68,6 +68,9 @@ typedef struct _application /** Binary API connection index, ~0 if internal */ u32 api_client_index; + /** Namespace the application belongs to */ + u32 ns_index; + /** Application listens for events on this svm queue */ unix_shared_memory_queue_t *event_queue; @@ -95,25 +98,24 @@ typedef struct _application segment_manager_properties_t sm_properties; } application_t; +#define APP_INVALID_INDEX ((u32)~0) +#define APP_NS_INVALID_INDEX ((u32)~0) #define APP_INVALID_SEGMENT_MANAGER_INDEX ((u32) ~0) application_t *application_new (); -int -application_init (application_t * app, u32 api_client_index, u64 * options, - session_cb_vft_t * cb_fns); +int application_init (application_t * app, u32 api_client_index, + u64 * options, session_cb_vft_t * cb_fns); void application_del (application_t * app); application_t *application_get (u32 index); application_t *application_get_if_valid (u32 index); application_t *application_lookup (u32 api_client_index); u32 application_get_index (application_t * app); -int -application_start_listen (application_t * app, session_type_t session_type, - transport_endpoint_t * tep, u64 * handle); +int application_start_listen (application_t * app, + session_endpoint_t * tep, u64 * handle); int application_stop_listen (application_t * srv, u64 handle); -int -application_open_session (application_t * app, session_type_t sst, - transport_endpoint_t * tep, u32 api_context); +int application_open_session (application_t * app, session_endpoint_t * tep, + u32 api_context); int application_api_queue_is_full (application_t * app); segment_manager_t *application_get_listen_segment_manager (application_t * @@ -124,6 +126,12 @@ segment_manager_t *application_get_connect_segment_manager (application_t * app); int application_is_proxy (application_t * app); int application_add_segment_notify (u32 app_index, u32 fifo_segment_index); +u32 application_session_table (application_t * app, u8 fib_proto); +u32 application_local_session_table (application_t * app); +u8 *application_name_from_index (u32 app_index); + +u8 application_has_local_scope (application_t * app); +u8 application_has_global_scope (application_t * app); #endif /* SRC_VNET_SESSION_APPLICATION_H_ */ diff --git a/src/vnet/session/application_interface.c b/src/vnet/session/application_interface.c index 7e7449aa161..a0dff90565a 100644 --- a/src/vnet/session/application_interface.c +++ b/src/vnet/session/application_interface.c @@ -17,45 +17,37 @@ #include <vnet/session/session.h> #include <vlibmemory/api.h> #include <vnet/dpo/load_balance.h> -#include <vnet/fib/ip4_fib.h> /** @file VPP's application/session API bind/unbind/connect/disconnect calls */ static u8 -ip_is_zero (ip46_address_t * ip46_address, u8 is_ip4) +session_endpoint_is_local (session_endpoint_t * sep) { - if (is_ip4) - return (ip46_address->ip4.as_u32 == 0); - else - return (ip46_address->as_u64[0] == 0 && ip46_address->as_u64[1] == 0); + return (ip_is_zero (&sep->ip, sep->is_ip4) + || ip_is_local_host (&sep->ip, sep->is_ip4)); } static u8 -ip_is_local (ip46_address_t * ip46_address, u8 is_ip4) +session_endpoint_is_zero (session_endpoint_t * sep) { - fib_node_index_t fei; - fib_entry_flag_t flags; - fib_prefix_t prefix; + return ip_is_zero (&sep->ip, sep->is_ip4); +} - /* Check if requester is local */ - if (is_ip4) - { - prefix.fp_len = 32; - prefix.fp_proto = FIB_PROTOCOL_IP4; - } - else +u8 +session_endpoint_in_ns (session_endpoint_t * sep) +{ + u8 is_zero = ip_is_zero (&sep->ip, sep->is_ip4); + if (!is_zero && sep->sw_if_index != ENDPOINT_INVALID_INDEX + && !ip_interface_has_address (sep->sw_if_index, &sep->ip, sep->is_ip4)) { - prefix.fp_len = 128; - prefix.fp_proto = FIB_PROTOCOL_IP6; + clib_warning ("sw_if_index %u not configured with ip %U", + sep->sw_if_index, format_ip46_address, &sep->ip, + sep->is_ip4); + return 0; } - - clib_memcpy (&prefix.fp_addr, ip46_address, sizeof (ip46_address_t)); - fei = fib_table_lookup (0, &prefix); - flags = fib_entry_get_flags (fei); - - return (flags & FIB_ENTRY_FLAG_LOCAL); + return (is_zero || ip_is_local (sep->fib_index, &sep->ip, sep->is_ip4)); } int @@ -78,76 +70,190 @@ api_parse_session_handle (u64 handle, u32 * session_index, u32 * thread_index) return 0; } -int -vnet_bind_i (u32 app_index, session_type_t sst, - transport_endpoint_t * tep, u64 * handle) +static void +session_endpoint_update_for_app (session_endpoint_t * sep, + application_t * app) +{ + app_namespace_t *app_ns; + app_ns = app_namespace_get (app->ns_index); + if (app_ns) + { + /* Ask transport and network to bind to/connect using local interface + * that "supports" app's namespace. This will fix our local connection + * endpoint. + */ + sep->sw_if_index = app_ns->sw_if_index; + sep->fib_index = + sep->is_ip4 ? app_ns->ip4_fib_index : app_ns->ip6_fib_index; + } +} + +static int +vnet_bind_i (u32 app_index, session_endpoint_t * sep, u64 * handle) { application_t *app; - stream_session_t *listener; + u32 table_index, listener_index; + int rv, have_local = 0; app = application_get_if_valid (app_index); if (!app) { - clib_warning ("app not attached"); + SESSION_DBG ("app not attached"); return VNET_API_ERROR_APPLICATION_NOT_ATTACHED; } - listener = stream_session_lookup_listener (&tep->ip, tep->port, sst); - if (listener) + session_endpoint_update_for_app (sep, app); + if (!session_endpoint_in_ns (sep)) + return VNET_API_ERROR_INVALID_VALUE_2; + + table_index = application_session_table (app, + session_endpoint_fib_proto (sep)); + listener_index = session_lookup_session_endpoint (table_index, sep); + if (listener_index != SESSION_INVALID_INDEX) return VNET_API_ERROR_ADDRESS_IN_USE; - if (!ip_is_zero (&tep->ip, tep->is_ip4) - && !ip_is_local (&tep->ip, tep->is_ip4)) - return VNET_API_ERROR_INVALID_VALUE_2; + /* + * Add session endpoint to local session table. Only binds to "inaddr_any" + * (i.e., zero address) are added to local scope table. + */ + if (application_has_local_scope (app) && session_endpoint_is_zero (sep)) + { + table_index = application_local_session_table (app); + listener_index = session_lookup_session_endpoint (table_index, sep); + if (listener_index != SESSION_INVALID_INDEX) + return VNET_API_ERROR_ADDRESS_IN_USE; + session_lookup_add_session_endpoint (table_index, sep, app->index); + *handle = session_lookup_local_listener_make_handle (sep); + have_local = 1; + } + + if (!application_has_global_scope (app)) + return (have_local - 1); + + /* + * Add session endpoint to global session table + */ /* Setup listen path down to transport */ - return application_start_listen (app, sst, tep, handle); + rv = application_start_listen (app, sep, handle); + if (rv && have_local) + session_lookup_del_session_endpoint (table_index, sep); + return rv; } int vnet_unbind_i (u32 app_index, u64 handle) { application_t *app = application_get_if_valid (app_index); + stream_session_t *listener = 0; + u32 table_index; if (!app) { - clib_warning ("app (%d) not attached", app_index); + SESSION_DBG ("app (%d) not attached", app_index); return VNET_API_ERROR_APPLICATION_NOT_ATTACHED; } - /* Clear the listener */ - return application_stop_listen (app, handle); + /* + * Clean up local session table. If we have a listener session use it to + * find the port and proto. If not, the handle must be a local table handle + * so parse it. + */ + + if (application_has_local_scope (app)) + { + session_endpoint_t sep = SESSION_ENDPOINT_NULL; + if (!session_lookup_local_is_handle (handle)) + listener = listen_session_get_from_handle (handle); + if (listener) + { + if (listen_session_get_local_session_endpoint (listener, &sep)) + { + clib_warning ("broken listener"); + return -1; + } + } + else + { + if (session_lookup_local_listener_parse_handle (handle, &sep)) + { + clib_warning ("can't parse handle"); + return -1; + } + } + table_index = application_local_session_table (app); + session_lookup_del_session_endpoint (table_index, &sep); + } + + /* + * Clear the global scope table of the listener + */ + if (application_has_global_scope (app)) + return application_stop_listen (app, handle); + return 0; +} + +static int +app_connect_redirect (application_t * server, void *mp) +{ + return server->cb_fns.redirect_connect_callback (server->api_client_index, + mp); } int -vnet_connect_i (u32 app_index, u32 api_context, session_type_t sst, - transport_endpoint_t * tep, void *mp) +vnet_connect_i (u32 app_index, u32 api_context, session_endpoint_t * sep, + void *mp) { - stream_session_t *listener; application_t *server, *app; + u32 table_index; + + if (session_endpoint_is_zero (sep)) + return VNET_API_ERROR_INVALID_VALUE; + + app = application_get (app_index); + session_endpoint_update_for_app (sep, app); /* - * Figure out if connecting to a local server + * First check the the local scope for locally attached destinations. + * If we have local scope, we pass *all* connects through it since we may + * have special policy rules even for non-local destinations, think proxy. */ - listener = stream_session_lookup_listener (&tep->ip, tep->port, sst); - if (listener) + if (application_has_local_scope (app)) { - server = application_get (listener->app_index); - + table_index = application_local_session_table (app); + app_index = session_lookup_local_session_endpoint (table_index, sep); + server = application_get (app_index); /* * Server is willing to have a direct fifo connection created * instead of going through the state machine, etc. */ - if (server->flags & APP_OPTIONS_FLAGS_USE_FIFO) - return server->cb_fns. - redirect_connect_callback (server->api_client_index, mp); + if (server && (server->flags & APP_OPTIONS_FLAGS_ACCEPT_REDIRECT)) + return app_connect_redirect (server, mp); } /* - * Not connecting to a local server. Create regular session + * If nothing found, check the global scope for locally attached + * destinations. Make sure first that we're allowed to. */ - app = application_get (app_index); - return application_open_session (app, sst, tep, api_context); + if (session_endpoint_is_local (sep)) + return VNET_API_ERROR_SESSION_CONNECT; + + if (!application_has_global_scope (app)) + return VNET_API_ERROR_APP_CONNECT_SCOPE; + + table_index = application_session_table (app, + session_endpoint_fib_proto (sep)); + app_index = session_lookup_session_endpoint (table_index, sep); + server = application_get (app_index); + if (server && (server->flags & APP_OPTIONS_FLAGS_ACCEPT_REDIRECT)) + return app_connect_redirect (server, mp); + + /* + * Not connecting to a local server, propagate to transport + */ + if (application_open_session (app, sep, api_context)) + return VNET_API_ERROR_SESSION_CONNECT; + return 0; } /** @@ -170,37 +276,38 @@ vnet_connect_i (u32 app_index, u32 api_context, session_type_t sst, uword unformat_vnet_uri (unformat_input_t * input, va_list * args) { - session_type_t *sst = va_arg (*args, session_type_t *); - transport_endpoint_t *tep = va_arg (*args, transport_endpoint_t *); + session_endpoint_t *sep = va_arg (*args, session_endpoint_t *); - if (unformat (input, "tcp://%U/%d", unformat_ip4_address, &tep->ip.ip4, - &tep->port)) + if (unformat (input, "tcp://%U/%d", unformat_ip4_address, &sep->ip.ip4, + &sep->port)) { - *sst = SESSION_TYPE_IP4_TCP; - tep->port = clib_host_to_net_u16 (tep->port); - tep->is_ip4 = 1; + sep->transport_proto = TRANSPORT_PROTO_TCP; + sep->port = clib_host_to_net_u16 (sep->port); + sep->is_ip4 = 1; return 1; } - if (unformat (input, "udp://%U/%d", unformat_ip4_address, &tep->ip.ip4, - &tep->port)) + if (unformat (input, "udp://%U/%d", unformat_ip4_address, &sep->ip.ip4, + &sep->port)) { - *sst = SESSION_TYPE_IP4_UDP; - tep->port = clib_host_to_net_u16 (tep->port); - tep->is_ip4 = 1; + sep->transport_proto = TRANSPORT_PROTO_UDP; + sep->port = clib_host_to_net_u16 (sep->port); + sep->is_ip4 = 1; return 1; } - if (unformat (input, "udp://%U/%d", unformat_ip6_address, &tep->ip.ip6, - &tep->port)) + if (unformat (input, "udp://%U/%d", unformat_ip6_address, &sep->ip.ip6, + &sep->port)) { - *sst = SESSION_TYPE_IP6_UDP; - tep->port = clib_host_to_net_u16 (tep->port); + sep->transport_proto = TRANSPORT_PROTO_UDP; + sep->port = clib_host_to_net_u16 (sep->port); + sep->is_ip4 = 0; return 1; } - if (unformat (input, "tcp://%U/%d", unformat_ip6_address, &tep->ip.ip6, - &tep->port)) + if (unformat (input, "tcp://%U/%d", unformat_ip6_address, &sep->ip.ip6, + &sep->port)) { - *sst = SESSION_TYPE_IP6_TCP; - tep->port = clib_host_to_net_u16 (tep->port); + sep->transport_proto = TRANSPORT_PROTO_TCP; + sep->port = clib_host_to_net_u16 (sep->port); + sep->is_ip4 = 0; return 1; } @@ -208,18 +315,16 @@ unformat_vnet_uri (unformat_input_t * input, va_list * args) } static u8 *cache_uri; -static session_type_t cache_sst; -static transport_endpoint_t *cache_tep; +static session_endpoint_t *cache_sep; int -parse_uri (char *uri, session_type_t * sst, transport_endpoint_t * tep) +parse_uri (char *uri, session_endpoint_t * sep) { unformat_input_t _input, *input = &_input; if (cache_uri && !strncmp (uri, (char *) cache_uri, vec_len (cache_uri))) { - *sst = cache_sst; - *tep = *cache_tep; + *sep = *cache_sep; return 0; } @@ -228,7 +333,7 @@ parse_uri (char *uri, session_type_t * sst, transport_endpoint_t * tep) /* Parse uri */ unformat_init_string (input, uri, strlen (uri)); - if (!unformat (input, "%U", unformat_vnet_uri, sst, tep)) + if (!unformat (input, "%U", unformat_vnet_uri, sep)) { unformat_free (input); return VNET_API_ERROR_INVALID_VALUE; @@ -237,34 +342,67 @@ parse_uri (char *uri, session_type_t * sst, transport_endpoint_t * tep) vec_free (cache_uri); cache_uri = (u8 *) uri; - cache_sst = *sst; - if (cache_tep) - clib_mem_free (cache_tep); - cache_tep = clib_mem_alloc (sizeof (*tep)); - *cache_tep = *tep; + if (cache_sep) + clib_mem_free (cache_sep); + cache_sep = clib_mem_alloc (sizeof (*sep)); + *cache_sep = *sep; return 0; } +static int +session_validate_namespace (u8 * namespace_id, u64 secret, u32 * app_ns_index) +{ + app_namespace_t *app_ns; + if (vec_len (namespace_id) == 0) + { + /* Use default namespace */ + *app_ns_index = 0; + return 0; + } + + *app_ns_index = app_namespace_index_from_id (namespace_id); + if (*app_ns_index == APP_NAMESPACE_INVALID_INDEX) + return VNET_API_ERROR_APP_INVALID_NS; + app_ns = app_namespace_get (*app_ns_index); + if (!app_ns) + return VNET_API_ERROR_APP_INVALID_NS; + if (app_ns->ns_secret != secret) + return VNET_API_ERROR_APP_WRONG_NS_SECRET; + return 0; +} + /** - * Attaches application. + * Attach application to vpp * * Allocates a vpp app, i.e., a structure that keeps back pointers * to external app and a segment manager for shared memory fifo based * communication with the external app. */ -int +clib_error_t * vnet_application_attach (vnet_app_attach_args_t * a) { application_t *app = 0; segment_manager_t *sm; u8 *seg_name; + u64 secret; + u32 app_ns_index = 0; int rv; + app = application_lookup (a->api_client_index); + if (app) + return clib_error_return_code (0, VNET_API_ERROR_APP_ALREADY_ATTACHED, + 0, "app already attached"); + + secret = a->options[APP_OPTIONS_NAMESPACE_SECRET]; + if ((rv = session_validate_namespace (a->namespace_id, secret, + &app_ns_index))) + return clib_error_return_code (0, rv, 0, "namespace validation: %d", rv); + a->options[APP_OPTIONS_NAMESPACE] = app_ns_index; app = application_new (); if ((rv = application_init (app, a->api_client_index, a->options, a->session_cb_vft))) - return rv; + return clib_error_return_code (0, rv, 0, "app init: %d", rv); a->app_event_queue_address = pointer_to_uword (app->event_queue); sm = segment_manager_get (app->first_segment_manager); @@ -278,6 +416,9 @@ vnet_application_attach (vnet_app_attach_args_t * a) return 0; } +/** + * Detach application from vpp + */ int vnet_application_detach (vnet_app_detach_args_t * a) { @@ -297,56 +438,48 @@ vnet_application_detach (vnet_app_detach_args_t * a) int vnet_bind_uri (vnet_bind_args_t * a) { - session_type_t sst = SESSION_N_TYPES; - transport_endpoint_t tep; + session_endpoint_t sep = SESSION_ENDPOINT_NULL; int rv; - memset (&tep, 0, sizeof (tep)); - rv = parse_uri (a->uri, &sst, &tep); + rv = parse_uri (a->uri, &sep); if (rv) return rv; - if ((rv = vnet_bind_i (a->app_index, sst, &tep, &a->handle))) - return rv; - - return 0; + return vnet_bind_i (a->app_index, &sep, &a->handle); } int vnet_unbind_uri (vnet_unbind_args_t * a) { - session_type_t sst = SESSION_N_TYPES; stream_session_t *listener; - transport_endpoint_t tep; + session_endpoint_t sep = SESSION_ENDPOINT_NULL; int rv; - rv = parse_uri (a->uri, &sst, &tep); + rv = parse_uri (a->uri, &sep); if (rv) return rv; - listener = stream_session_lookup_listener (&tep.ip, - clib_host_to_net_u16 (tep.port), - sst); + /* NOTE: only default table supported for uri */ + listener = session_lookup_listener (0, &sep); if (!listener) return VNET_API_ERROR_ADDRESS_NOT_IN_USE; return vnet_unbind_i (a->app_index, listen_session_get_handle (listener)); } -int +clib_error_t * vnet_connect_uri (vnet_connect_args_t * a) { - transport_endpoint_t tep; - session_type_t sst; + session_endpoint_t sep = SESSION_ENDPOINT_NULL; int rv; /* Parse uri */ - memset (&tep, 0, sizeof (tep)); - rv = parse_uri (a->uri, &sst, &tep); + rv = parse_uri (a->uri, &sep); if (rv) - return rv; - - return vnet_connect_i (a->app_index, a->api_context, sst, &tep, a->mp); + return clib_error_return_code (0, rv, 0, "app init: %d", rv); + if ((rv = vnet_connect_i (a->app_index, a->api_context, &sep, a->mp))) + return clib_error_return_code (0, rv, 0, "connect failed"); + return 0; } int @@ -355,7 +488,7 @@ vnet_disconnect_session (vnet_disconnect_args_t * a) u32 index, thread_index; stream_session_t *s; - stream_session_parse_handle (a->handle, &index, &thread_index); + session_parse_handle (a->handle, &index, &thread_index); s = stream_session_get_if_valid (index, thread_index); if (!s || s->app_index != a->app_index) @@ -369,32 +502,31 @@ vnet_disconnect_session (vnet_disconnect_args_t * a) return 0; } -int +clib_error_t * vnet_bind (vnet_bind_args_t * a) { - session_type_t sst = SESSION_N_TYPES; int rv; - - sst = session_type_from_proto_and_ip (a->proto, a->tep.is_ip4); - if ((rv = vnet_bind_i (a->app_index, sst, &a->tep, &a->handle))) - return rv; - + if ((rv = vnet_bind_i (a->app_index, &a->sep, &a->handle))) + return clib_error_return_code (0, rv, 0, "bind failed"); return 0; } -int +clib_error_t * vnet_unbind (vnet_unbind_args_t * a) { - return vnet_unbind_i (a->app_index, a->handle); + int rv; + if ((rv = vnet_unbind_i (a->app_index, a->handle))) + return clib_error_return_code (0, rv, 0, "unbind failed"); + return 0; } -int +clib_error_t * vnet_connect (vnet_connect_args_t * a) { - session_type_t sst; - - sst = session_type_from_proto_and_ip (a->proto, a->tep.is_ip4); - return vnet_connect_i (a->app_index, a->api_context, sst, &a->tep, a->mp); + int rv; + if ((rv = vnet_connect_i (a->app_index, a->api_context, &a->sep, a->mp))) + return clib_error_return_code (0, rv, 0, "connect failed"); + return 0; } /* diff --git a/src/vnet/session/application_interface.h b/src/vnet/session/application_interface.h index 1d63f6cc102..5e1fe8ee528 100644 --- a/src/vnet/session/application_interface.h +++ b/src/vnet/session/application_interface.h @@ -30,12 +30,12 @@ typedef struct _vnet_app_attach_args_t /** Application and segment manager options */ u64 *options; + /* Namespace id */ + u8 *namespace_id; + /** Session to application callback functions */ session_cb_vft_t *session_cb_vft; - /** Flag that indicates if app is builtin */ - u8 builtin; - /* * Results */ @@ -58,7 +58,7 @@ typedef struct _vnet_bind_args_t char *uri; struct { - transport_endpoint_t tep; + session_endpoint_t sep; transport_proto_t proto; }; }; @@ -91,7 +91,7 @@ typedef struct _vnet_connect_args char *uri; struct { - transport_endpoint_t tep; + session_endpoint_t sep; transport_proto_t proto; }; }; @@ -119,6 +119,8 @@ typedef enum APP_OPTIONS_PREALLOC_FIFO_PAIRS, APP_OPTIONS_PRIVATE_SEGMENT_COUNT, APP_OPTIONS_PRIVATE_SEGMENT_SIZE, + APP_OPTIONS_NAMESPACE, + APP_OPTIONS_NAMESPACE_SECRET, SESSION_OPTIONS_SEGMENT_SIZE, SESSION_OPTIONS_ADD_SEGMENT_SIZE, SESSION_OPTIONS_RX_FIFO_SIZE, @@ -129,10 +131,12 @@ typedef enum } app_attach_options_index_t; #define foreach_app_options_flags \ - _(USE_FIFO, "Use FIFO with redirects") \ + _(ACCEPT_REDIRECT, "Use FIFO with redirects") \ _(ADD_SEGMENT, "Add segment and signal app if needed") \ _(BUILTIN_APP, "Application is builtin") \ - _(IS_PROXY, "Application is proxying") + _(IS_PROXY, "Application is proxying") \ + _(USE_GLOBAL_SCOPE, "App can use global session scope") \ + _(USE_LOCAL_SCOPE, "App can use local session scope") typedef enum _app_options { @@ -148,25 +152,17 @@ typedef enum _app_options_flags #undef _ } app_options_flags_t; -///** Server can handle delegated connect requests from local clients */ -//#define APP_OPTIONS_FLAGS_USE_FIFO (1<<0) -// -///** Server wants vpp to add segments when out of memory for fifos */ -//#define APP_OPTIONS_FLAGS_ADD_SEGMENT (1<<1) - -#define VNET_CONNECT_REDIRECTED 123 - -int vnet_application_attach (vnet_app_attach_args_t * a); +clib_error_t *vnet_application_attach (vnet_app_attach_args_t * a); int vnet_application_detach (vnet_app_detach_args_t * a); int vnet_bind_uri (vnet_bind_args_t *); int vnet_unbind_uri (vnet_unbind_args_t * a); -int vnet_connect_uri (vnet_connect_args_t * a); +clib_error_t *vnet_connect_uri (vnet_connect_args_t * a); int vnet_disconnect_session (vnet_disconnect_args_t * a); -int vnet_bind (vnet_bind_args_t * a); -int vnet_connect (vnet_connect_args_t * a); -int vnet_unbind (vnet_unbind_args_t * a); +clib_error_t *vnet_bind (vnet_bind_args_t * a); +clib_error_t *vnet_connect (vnet_connect_args_t * a); +clib_error_t *vnet_unbind (vnet_unbind_args_t * a); int api_parse_session_handle (u64 handle, u32 * session_index, diff --git a/src/vnet/session/application_namespace.c b/src/vnet/session/application_namespace.c new file mode 100644 index 00000000000..7f90943f9cd --- /dev/null +++ b/src/vnet/session/application_namespace.c @@ -0,0 +1,293 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <vnet/session/application_namespace.h> +#include <vnet/session/session_table.h> +#include <vnet/session/session.h> +#include <vnet/fib/fib_table.h> + +/** + * Hash table of application namespaces by app ns ids + */ +uword *app_namespace_lookup_table; + +/** + * Pool of application namespaces + */ +static app_namespace_t *app_namespace_pool; + +app_namespace_t * +app_namespace_get (u32 index) +{ + return pool_elt_at_index (app_namespace_pool, index); +} + +app_namespace_t * +app_namespace_get_from_id (const u8 * ns_id) +{ + u32 index = app_namespace_index_from_id (ns_id); + if (index == APP_NAMESPACE_INVALID_INDEX) + return 0; + return app_namespace_get (index); +} + +u32 +app_namespace_index (app_namespace_t * app_ns) +{ + return (app_ns - app_namespace_pool); +} + +app_namespace_t * +app_namespace_alloc (u8 * ns_id) +{ + app_namespace_t *app_ns; + pool_get (app_namespace_pool, app_ns); + memset (app_ns, 0, sizeof (*app_ns)); + app_ns->ns_id = vec_dup (ns_id); + hash_set_mem (app_namespace_lookup_table, app_ns->ns_id, + app_ns - app_namespace_pool); + return app_ns; +} + +clib_error_t * +vnet_app_namespace_add_del (vnet_app_namespace_add_del_args_t * a) +{ + app_namespace_t *app_ns; + session_table_t *st; + + if (a->is_add) + { + if (a->sw_if_index != APP_NAMESPACE_INVALID_INDEX + && !vnet_get_sw_interface_safe (vnet_get_main (), a->sw_if_index)) + return clib_error_return_code (0, VNET_API_ERROR_INVALID_SW_IF_INDEX, + 0, "sw_if_index %u doesn't exist", + a->sw_if_index); + + if (a->sw_if_index != APP_NAMESPACE_INVALID_INDEX) + { + a->ip4_fib_id = + fib_table_get_table_id_for_sw_if_index (FIB_PROTOCOL_IP4, + a->sw_if_index); + a->ip6_fib_id = + fib_table_get_table_id_for_sw_if_index (FIB_PROTOCOL_IP4, + a->sw_if_index); + } + if (a->sw_if_index == APP_NAMESPACE_INVALID_INDEX + && a->ip4_fib_id == APP_NAMESPACE_INVALID_INDEX) + return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0, + "sw_if_index or fib_id must be " + "configured"); + st = session_table_alloc (); + session_table_init (st); + + app_ns = app_namespace_get_from_id (a->ns_id); + if (!app_ns) + app_ns = app_namespace_alloc (a->ns_id); + app_ns->ns_secret = a->secret; + app_ns->sw_if_index = a->sw_if_index; + app_ns->local_table_index = session_table_index (st); + app_ns->ip4_fib_index = + fib_table_find (FIB_PROTOCOL_IP4, a->ip4_fib_id); + app_ns->ip6_fib_index = + fib_table_find (FIB_PROTOCOL_IP6, a->ip6_fib_id); + } + else + { + return clib_error_return_code (0, VNET_API_ERROR_UNIMPLEMENTED, 0, + "namespace deletion not supported"); + } + return 0; +} + +const u8 * +app_namespace_id (app_namespace_t * app_ns) +{ + return app_ns->ns_id; +} + +u32 +app_namespace_index_from_id (const u8 * ns_id) +{ + uword *indexp; + indexp = hash_get_mem (app_namespace_lookup_table, ns_id); + if (!indexp) + return APP_NAMESPACE_INVALID_INDEX; + return *indexp; +} + +const u8 * +app_namespace_id_from_index (u32 index) +{ + app_namespace_t *app_ns; + + app_ns = app_namespace_get (index); + return app_namespace_id (app_ns); +} + +void +app_namespaces_init (void) +{ + u8 *ns_id = format (0, "default"); + app_namespace_lookup_table = + hash_create_vec (0, sizeof (u8), sizeof (uword)); + + /* + * Allocate default namespace + */ + vnet_app_namespace_add_del_args_t a = { + .ns_id = ns_id, + .secret = 0, + .sw_if_index = APP_NAMESPACE_INVALID_INDEX, + .is_add = 1 + }; + vnet_app_namespace_add_del (&a); + vec_free (ns_id); +} + +static clib_error_t * +app_ns_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + u8 is_add = 0, *ns_id = 0, secret_set = 0, sw_if_index_set = 0; + u32 sw_if_index, fib_id = APP_NAMESPACE_INVALID_INDEX; + u64 secret; + clib_error_t *error = 0; + + session_cli_return_if_not_enabled (); + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "add")) + is_add = 1; + else if (unformat (input, "id %_%v%_", &ns_id)) + ; + else if (unformat (input, "secret %lu", &secret)) + secret_set = 1; + else if (unformat (input, "sw_if_index %u", &sw_if_index)) + sw_if_index_set = 1; + else if (unformat (input, "fib_id", &fib_id)) + ; + else + return clib_error_return (0, "unknown input `%U'", + format_unformat_error, input); + } + + if (!ns_id || !secret_set || !sw_if_index_set) + { + vlib_cli_output (vm, "namespace-id, secret and sw_if_index must be " + "provided"); + return 0; + } + + if (is_add) + { + vnet_app_namespace_add_del_args_t args = { + .ns_id = ns_id, + .secret = secret, + .sw_if_index = sw_if_index, + .ip4_fib_id = fib_id, + .is_add = 1 + }; + error = vnet_app_namespace_add_del (&args); + } + + return error; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (app_ns_command, static) = +{ + .path = "app ns", + .short_help = "app ns [add] id <namespace-id> secret <secret> " + "sw_if_index <sw_if_index>", + .function = app_ns_fn, +}; +/* *INDENT-ON* */ + +u8 * +format_app_namespace (u8 * s, va_list * args) +{ + app_namespace_t *app_ns = va_arg (*args, app_namespace_t *); + s = format (s, "%-20v%-20lu%-20u", app_ns->ns_id, app_ns->ns_secret, + app_ns->sw_if_index); + return s; +} + +static clib_error_t * +show_app_ns_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + app_namespace_t *app_ns; + session_table_t *st; + u8 *ns_id, do_table = 0; + + session_cli_return_if_not_enabled (); + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "table %_%v%_", &ns_id)) + do_table = 1; + else + return clib_error_return (0, "unknown input `%U'", + format_unformat_error, input); + } + + if (do_table) + { + app_ns = app_namespace_get_from_id (ns_id); + if (!app_ns) + { + vlib_cli_output (vm, "ns %v not found", ns_id); + return 0; + } + st = session_table_get (app_ns->local_table_index); + if (!st) + { + vlib_cli_output (vm, "table for ns %v could not be found", ns_id); + return 0; + } + session_lookup_show_table_entries (vm, st, 0, 1); + vec_free (ns_id); + return 0; + } + + vlib_cli_output (vm, "%-20s%-20s%-20s", "Namespace", "Secret", + "sw_if_index"); + + /* *INDENT-OFF* */ + pool_foreach (app_ns, app_namespace_pool, ({ + vlib_cli_output (vm, "%U", format_app_namespace, app_ns); + })); + /* *INDENT-ON* */ + + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (show_app_ns_command, static) = +{ + .path = "show app ns", + .short_help = "show app ns", + .function = show_app_ns_fn, +}; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/session/application_namespace.h b/src/vnet/session/application_namespace.h new file mode 100644 index 00000000000..da3f6017961 --- /dev/null +++ b/src/vnet/session/application_namespace.h @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <vnet/vnet.h> + +#ifndef SRC_VNET_SESSION_APPLICATION_NAMESPACE_H_ +#define SRC_VNET_SESSION_APPLICATION_NAMESPACE_H_ + +typedef struct _app_namespace +{ + /** + * Local sw_if_index that supports transport connections for this namespace + */ + u32 sw_if_index; + + /** + * Network namespace (e.g., fib_index associated to the sw_if_index) + * wherein connections are to be established. Since v4 and v6 fibs are + * separate, we actually need to keep pointers to both. + */ + u32 ip4_fib_index; + u32 ip6_fib_index; + + /** + * Local session table associated to ns + */ + u32 local_table_index; + + /** + * Secret apps need to provide to authorize attachment to the namespace + */ + u64 ns_secret; + + /** + * Application namespace id + */ + u8 *ns_id; +} app_namespace_t; + +typedef struct _vnet_app_namespace_add_del_args +{ + u8 *ns_id; + u64 secret; + u32 sw_if_index; + u32 ip4_fib_id; + u32 ip6_fib_id; + u8 is_add; +} vnet_app_namespace_add_del_args_t; + +#define APP_NAMESPACE_INVALID_INDEX ((u32)~0) + +app_namespace_t *app_namespace_alloc (u8 * ns_id); +app_namespace_t *app_namespace_get (u32 index); +app_namespace_t *app_namespace_get_from_id (const u8 * ns_id); +u32 app_namespace_index (app_namespace_t * app_ns); +const u8 *app_namespace_id (app_namespace_t * app_ns); +const u8 *app_namespace_id_from_index (u32 index); +u32 app_namespace_index_from_id (const u8 * ns_id); +void app_namespaces_init (void); +clib_error_t *vnet_app_namespace_add_del (vnet_app_namespace_add_del_args_t * + a); + +#endif /* SRC_VNET_SESSION_APPLICATION_NAMESPACE_H_ */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/session/segment_manager.c b/src/vnet/session/segment_manager.c index 48d027553b1..f35dec72d88 100644 --- a/src/vnet/session/segment_manager.c +++ b/src/vnet/session/segment_manager.c @@ -267,7 +267,7 @@ segment_manager_del_sessions (segment_manager_t * sm) session_index = fifo->master_session_index; thread_index = fifo->master_thread_index; - session = stream_session_get (session_index, thread_index); + session = session_get (session_index, thread_index); /* Instead of directly removing the session call disconnect */ if (session->session_state != SESSION_STATE_CLOSED) diff --git a/src/vnet/session/session.api b/src/vnet/session/session.api index 992a0638698..12a5d10429c 100644 --- a/src/vnet/session/session.api +++ b/src/vnet/session/session.api @@ -21,12 +21,16 @@ vl_api_version 1.0.0 @param initial_segment_size - size of the initial shm segment to be allocated @param options - segment size, fifo sizes, etc. + @param namespace_id_len - length of the namespace id c-string + @param namespace_id - 0 terminted c-string */ define application_attach { u32 client_index; u32 context; u32 initial_segment_size; u64 options[16]; + u8 namespace_id_len; + u8 namespace_id [64]; }; /** \brief Application attach reply @@ -99,20 +103,19 @@ autoreply define unbind_uri { /** \brief Connect to a given URI @param client_index - opaque cookie to identify the sender @param context - sender context, to match reply w/ request - @param accept_cookie - sender accept cookie, to identify this bind flavor - @param uri - a URI, e.g. "tcp4://0.0.0.0/0/80" - "tcp6://::/0/80" [ipv6], etc. - @param options - socket options, fifo sizes, etc. passed by vpp to the - server when redirecting connects @param client_queue_address - binary API client queue address. Used by local server when connect was redirected. + @param options - socket options, fifo sizes, etc. passed by vpp to the + server when redirecting connects + @param uri - a URI, e.g. "tcp4://0.0.0.0/0/80" + "tcp6://::/0/80" [ipv6], etc. */ autoreply define connect_uri { u32 client_index; u32 context; - u8 uri[128]; u64 client_queue_address; u64 options[16]; + u8 uri[128]; }; /** \brief vpp->client, accept this session @@ -240,26 +243,25 @@ autoreply define unbind_sock { /** \brief Connect to a remote peer @param client_index - opaque cookie to identify the sender @param context - sender context, to match reply w/ request - @param app_connect - application connection id to be returned in reply + @param client_queue_address - client's API queue address. Non-zero when + used to perform redirects + @param options - socket options, fifo sizes, etc. when doing redirects @param vrf - connection namespace @param is_ip4 - flag that is 1 if ip address family is IPv4 @param ip - ip address @param port - port @param proto - protocol 0 - TCP 1 - UDP - @param client_queue_address - client's API queue address. Non-zero when - used to perform redirects - @param options - socket options, fifo sizes, etc. when doing redirects */ autoreply define connect_sock { u32 client_index; u32 context; + u64 client_queue_address; + u64 options[16]; u32 vrf; u8 is_ip4; u8 ip[16]; u16 port; u8 proto; - u64 client_queue_address; - u64 options[16]; }; /** \brief Bind reply @@ -326,6 +328,31 @@ autoreply define session_enable_disable { u8 is_enable; }; +/** \brief add/del application namespace + @param client_index - opaque cookie to identify the sender + client to vpp direction only + @param context - sender context, to match reply w/ request + @param secret - secret shared between app and vpp + @param sw_if_index - local interface that "supports" namespace. Set to + ~0 if no preference + @param ip4_fib_id - id of ip4 fib that "supports" the namespace. Ignored + if sw_if_index set. + @param ip6_fib_id - id of ip6 fib that "supports" the namespace. Ignored + if sw_if_index set. + @param namespace_id_len - length of namespace id lower + @param namespace_id - namespace id +*/ +autoreply define app_namespace_add_del { + u32 client_index; + u32 context; + u64 secret; + u32 sw_if_index; + u32 ip4_fib_id; + u32 ip6_fib_id; + u8 namespace_id_len; + u8 namespace_id[64]; +}; + /* * Local Variables: * eval: (c-set-style "gnu") diff --git a/src/vnet/session/session.c b/src/vnet/session/session.c index dc930ce87d3..88b38f15a61 100644 --- a/src/vnet/session/session.c +++ b/src/vnet/session/session.c @@ -85,7 +85,7 @@ stream_session_create_i (segment_manager_t * sm, transport_connection_t * tc, /* Add to the main lookup table */ value = stream_session_handle (s); - stream_session_table_add_for_tc (tc, value); + session_lookup_add_connection (tc, value); *ret_s = s; @@ -223,7 +223,7 @@ stream_session_enqueue_data (transport_connection_t * tc, vlib_buffer_t * b, stream_session_t *s; int enqueued = 0, rv, in_order_off; - s = stream_session_get (tc->s_index, tc->thread_index); + s = session_get (tc->s_index, tc->thread_index); if (is_in_order) { @@ -275,7 +275,7 @@ u8 stream_session_no_space (transport_connection_t * tc, u32 thread_index, u16 data_len) { - stream_session_t *s = stream_session_get (tc->s_index, thread_index); + stream_session_t *s = session_get (tc->s_index, thread_index); if (PREDICT_FALSE (s->session_state != SESSION_STATE_READY)) return 1; @@ -289,7 +289,7 @@ stream_session_no_space (transport_connection_t * tc, u32 thread_index, u32 stream_session_tx_fifo_max_dequeue (transport_connection_t * tc) { - stream_session_t *s = stream_session_get (tc->s_index, tc->thread_index); + stream_session_t *s = session_get (tc->s_index, tc->thread_index); if (!s->server_tx_fifo) return 0; return svm_fifo_max_dequeue (s->server_tx_fifo); @@ -299,14 +299,14 @@ int stream_session_peek_bytes (transport_connection_t * tc, u8 * buffer, u32 offset, u32 max_bytes) { - stream_session_t *s = stream_session_get (tc->s_index, tc->thread_index); + stream_session_t *s = session_get (tc->s_index, tc->thread_index); return svm_fifo_peek (s->server_tx_fifo, offset, max_bytes, buffer); } u32 stream_session_dequeue_drop (transport_connection_t * tc, u32 max_bytes) { - stream_session_t *s = stream_session_get (tc->s_index, tc->thread_index); + stream_session_t *s = session_get (tc->s_index, tc->thread_index); return svm_fifo_dequeue_drop (s->server_tx_fifo, max_bytes); } @@ -432,7 +432,7 @@ stream_session_init_fifos_pointers (transport_connection_t * tc, u32 rx_pointer, u32 tx_pointer) { stream_session_t *s; - s = stream_session_get (tc->s_index, tc->thread_index); + s = session_get (tc->s_index, tc->thread_index); svm_fifo_init_pointers (s->server_rx_fifo, rx_pointer); svm_fifo_init_pointers (s->server_tx_fifo, tx_pointer); } @@ -445,20 +445,16 @@ stream_session_connect_notify (transport_connection_t * tc, u8 is_fail) u64 handle; u32 opaque = 0; int error = 0; - u8 st; - st = session_type_from_proto_and_ip (tc->transport_proto, tc->is_ip4); - handle = stream_session_half_open_lookup_handle (&tc->lcl_ip, &tc->rmt_ip, - tc->lcl_port, tc->rmt_port, - st); + handle = session_lookup_half_open_handle (tc); if (handle == HALF_OPEN_LOOKUP_INVALID_VALUE) { - TCP_DBG ("half-open was removed!"); + SESSION_DBG ("half-open was removed!"); return -1; } /* Cleanup half-open table */ - stream_session_half_open_table_del (tc); + session_lookup_del_half_open (tc); /* Get the app's index from the handle we stored when opening connection * and the opaque (api_context for external apps) from transport session @@ -489,7 +485,7 @@ stream_session_connect_notify (transport_connection_t * tc, u8 is_fail) if (app->cb_fns.session_connected_callback (app->index, opaque, new_s, is_fail)) { - clib_warning ("failed to notify app"); + SESSION_DBG ("failed to notify app"); if (!is_fail) stream_session_disconnect (new_s); } @@ -508,7 +504,7 @@ stream_session_accept_notify (transport_connection_t * tc) application_t *server; stream_session_t *s; - s = stream_session_get (tc->s_index, tc->thread_index); + s = session_get (tc->s_index, tc->thread_index); server = application_get (s->app_index); server->cb_fns.session_accept_callback (s); } @@ -526,7 +522,7 @@ stream_session_disconnect_notify (transport_connection_t * tc) application_t *server; stream_session_t *s; - s = stream_session_get (tc->s_index, tc->thread_index); + s = session_get (tc->s_index, tc->thread_index); server = application_get (s->app_index); server->cb_fns.session_disconnect_callback (s); } @@ -541,7 +537,7 @@ stream_session_delete (stream_session_t * s) int rv; /* Delete from the main lookup table. */ - if ((rv = stream_session_table_del (s))) + if ((rv = session_lookup_del_session (s))) clib_warning ("hash delete error, rv %d", rv); /* Cleanup fifo segments */ @@ -581,7 +577,7 @@ stream_session_reset_notify (transport_connection_t * tc) { stream_session_t *s; application_t *app; - s = stream_session_get (tc->s_index, tc->thread_index); + s = session_get (tc->s_index, tc->thread_index); app = application_get (s->app_index); app->cb_fns.session_reset_callback (s); @@ -592,14 +588,16 @@ stream_session_reset_notify (transport_connection_t * tc) */ int stream_session_accept (transport_connection_t * tc, u32 listener_index, - u8 sst, u8 notify) + u8 notify) { application_t *server; stream_session_t *s, *listener; segment_manager_t *sm; - + session_type_t sst; int rv; + sst = session_type_from_proto_and_ip (tc->transport_proto, tc->is_ip4); + /* Find the server */ listener = listen_session_get (sst, listener_index); server = application_get (listener->app_index); @@ -634,22 +632,23 @@ stream_session_accept (transport_connection_t * tc, u32 listener_index, * @param res Resulting transport connection . */ int -stream_session_open (u32 app_index, session_type_t st, - transport_endpoint_t * rmt, +stream_session_open (u32 app_index, session_endpoint_t * rmt, transport_connection_t ** res) { transport_connection_t *tc; + session_type_t sst; int rv; u64 handle; - rv = tp_vfts[st].open (rmt); + sst = session_type_from_proto_and_ip (rmt->transport_proto, rmt->is_ip4); + rv = tp_vfts[sst].open (session_endpoint_to_transport (rmt)); if (rv < 0) { clib_warning ("Transport failed to open connection."); - return VNET_API_ERROR_SESSION_CONNECT_FAIL; + return VNET_API_ERROR_SESSION_CONNECT; } - tc = tp_vfts[st].get_half_open ((u32) rv); + tc = tp_vfts[sst].get_half_open ((u32) rv); /* Save app and tc index. The latter is needed to help establish the * connection while the former is needed when the connect notify comes @@ -657,7 +656,7 @@ stream_session_open (u32 app_index, session_type_t st, handle = (((u64) app_index) << 32) | (u64) tc->c_index; /* Add to the half-open lookup table */ - stream_session_half_open_table_add (tc, handle); + session_lookup_add_half_open (tc, handle); *res = tc; @@ -673,13 +672,14 @@ stream_session_open (u32 app_index, session_type_t st, * @param tep Local endpoint to be listened on. */ int -stream_session_listen (stream_session_t * s, transport_endpoint_t * tep) +stream_session_listen (stream_session_t * s, session_endpoint_t * tep) { transport_connection_t *tc; u32 tci; /* Transport bind/listen */ - tci = tp_vfts[s->session_type].bind (s->session_index, tep); + tci = tp_vfts[s->session_type].bind (s->session_index, + session_endpoint_to_transport (tep)); if (tci == (u32) ~ 0) return -1; @@ -693,7 +693,7 @@ stream_session_listen (stream_session_t * s, transport_endpoint_t * tep) return -1; /* Add to the main lookup table */ - stream_session_table_add_for_tc (tc, s->session_index); + session_lookup_add_connection (tc, s->session_index); return 0; } @@ -721,7 +721,7 @@ stream_session_stop_listen (stream_session_t * s) return VNET_API_ERROR_ADDRESS_NOT_IN_USE; } - stream_session_table_del_for_tc (tc); + session_lookup_del_connection (tc); tp_vfts[s->session_type].unbind (s->connection_index); return 0; } @@ -780,7 +780,7 @@ stream_session_cleanup (stream_session_t * s) s->session_state = SESSION_STATE_CLOSED; /* Delete from the main lookup table to avoid more enqueues */ - rv = stream_session_table_del (s); + rv = session_lookup_del_session (s); if (rv) clib_warning ("hash delete error, rv %d", rv); @@ -837,6 +837,26 @@ session_type_from_proto_and_ip (transport_proto_t proto, u8 is_ip4) return SESSION_N_TYPES; } +int +listen_session_get_local_session_endpoint (stream_session_t * listener, + session_endpoint_t * sep) +{ + transport_connection_t *tc; + tc = + tp_vfts[listener->session_type].get_listener (listener->connection_index); + if (!tc) + { + clib_warning ("no transport"); + return -1; + } + + /* N.B. The ip should not be copied because this is the local endpoint */ + sep->port = tc->lcl_port; + sep->transport_proto = tc->transport_proto; + sep->is_ip4 = tc->is_ip4; + return 0; +} + static clib_error_t * session_manager_main_enable (vlib_main_t * vm) { @@ -903,6 +923,7 @@ session_manager_main_enable (vlib_main_t * vm) } session_lookup_init (); + app_namespaces_init (); smm->is_enabled = 1; @@ -927,14 +948,14 @@ session_node_enable_disable (u8 is_en) clib_error_t * vnet_session_enable_disable (vlib_main_t * vm, u8 is_en) { + clib_error_t *error = 0; if (is_en) { if (session_manager_main.is_enabled) return 0; session_node_enable_disable (is_en); - - return session_manager_main_enable (vm); + error = session_manager_main_enable (vm); } else { @@ -942,7 +963,7 @@ vnet_session_enable_disable (vlib_main_t * vm, u8 is_en) session_node_enable_disable (is_en); } - return 0; + return error; } clib_error_t * diff --git a/src/vnet/session/session.h b/src/vnet/session/session.h index 83addec2744..b1a03d213e9 100644 --- a/src/vnet/session/session.h +++ b/src/vnet/session/session.h @@ -214,7 +214,7 @@ stream_session_is_valid (u32 si, u8 thread_index) } always_inline stream_session_t * -stream_session_get (u32 si, u32 thread_index) +session_get (u32 si, u32 thread_index) { ASSERT (stream_session_is_valid (si, thread_index)); return pool_elt_at_index (session_manager_main.sessions[thread_index], si); @@ -240,31 +240,31 @@ stream_session_handle (stream_session_t * s) } always_inline u32 -stream_session_index_from_handle (u64 handle) +session_index_from_handle (u64 handle) { return handle & 0xFFFFFFFF; } always_inline u32 -stream_session_thread_from_handle (u64 handle) +session_thread_from_handle (u64 handle) { return handle >> 32; } always_inline void -stream_session_parse_handle (u64 handle, u32 * index, u32 * thread_index) +session_parse_handle (u64 handle, u32 * index, u32 * thread_index) { - *index = stream_session_index_from_handle (handle); - *thread_index = stream_session_thread_from_handle (handle); + *index = session_index_from_handle (handle); + *thread_index = session_thread_from_handle (handle); } always_inline stream_session_t * -stream_session_get_from_handle (u64 handle) +session_get_from_handle (u64 handle) { session_manager_main_t *smm = &session_manager_main; - return pool_elt_at_index (smm->sessions[stream_session_thread_from_handle - (handle)], - stream_session_index_from_handle (handle)); + return + pool_elt_at_index (smm->sessions[session_thread_from_handle (handle)], + session_index_from_handle (handle)); } always_inline stream_session_t * @@ -285,14 +285,14 @@ stream_session_get_index (stream_session_t * s) always_inline u32 stream_session_max_rx_enqueue (transport_connection_t * tc) { - stream_session_t *s = stream_session_get (tc->s_index, tc->thread_index); + stream_session_t *s = session_get (tc->s_index, tc->thread_index); return svm_fifo_max_enqueue (s->server_rx_fifo); } always_inline u32 stream_session_rx_fifo_size (transport_connection_t * tc) { - stream_session_t *s = stream_session_get (tc->s_index, tc->thread_index); + stream_session_t *s = session_get (tc->s_index, tc->thread_index); return s->server_rx_fifo->nitems; } @@ -316,12 +316,11 @@ void stream_session_delete_notify (transport_connection_t * tc); void stream_session_reset_notify (transport_connection_t * tc); int stream_session_accept (transport_connection_t * tc, u32 listener_index, - u8 sst, u8 notify); + u8 notify); int -stream_session_open (u32 app_index, session_type_t st, - transport_endpoint_t * tep, +stream_session_open (u32 app_index, session_endpoint_t * tep, transport_connection_t ** tc); -int stream_session_listen (stream_session_t * s, transport_endpoint_t * tep); +int stream_session_listen (stream_session_t * s, session_endpoint_t * tep); int stream_session_stop_listen (stream_session_t * s); void stream_session_disconnect (stream_session_t * s); void stream_session_cleanup (stream_session_t * s); @@ -401,6 +400,10 @@ listen_session_del (stream_session_t * s) pool_put (session_manager_main.listen_sessions[s->session_type], s); } +int +listen_session_get_local_session_endpoint (stream_session_t * listener, + session_endpoint_t * sep); + always_inline stream_session_t * session_manager_get_listener (u8 type, u32 index) { @@ -425,6 +428,12 @@ session_manager_is_enabled () return session_manager_main.is_enabled == 1; } +#define session_cli_return_if_not_enabled() \ +do { \ + if (!session_manager_main.is_enabled) \ + return clib_error_return(0, "session layer is not enabled"); \ +} while (0) + #endif /* __included_session_h__ */ /* diff --git a/src/vnet/session/session_api.c b/src/vnet/session/session_api.c index 60d9b4de51b..5bfca7be6fc 100755 --- a/src/vnet/session/session_api.c +++ b/src/vnet/session/session_api.c @@ -47,10 +47,11 @@ _(DISCONNECT_SESSION, disconnect_session) \ _(DISCONNECT_SESSION_REPLY, disconnect_session_reply) \ _(ACCEPT_SESSION_REPLY, accept_session_reply) \ _(RESET_SESSION_REPLY, reset_session_reply) \ -_(BIND_SOCK, bind_sock) \ +_(BIND_SOCK, bind_sock) \ _(UNBIND_SOCK, unbind_sock) \ _(CONNECT_SOCK, connect_sock) \ _(SESSION_ENABLE_DISABLE, session_enable_disable) \ +_(APP_NAMESPACE_ADD_DEL, app_namespace_add_del) \ static int send_add_segment_callback (u32 api_client_index, const u8 * segment_name, @@ -180,7 +181,7 @@ send_session_connected_callback (u32 app_index, u32 api_context, } else { - mp->retval = clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT_FAIL); + mp->retval = clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT); } vl_msg_api_send_shmem (q, (u8 *) & mp); @@ -195,7 +196,7 @@ send_session_connected_callback (u32 app_index, u32 api_context, static int redirect_connect_callback (u32 server_api_client_index, void *mp_arg) { - vl_api_connect_uri_t *mp = mp_arg; + vl_api_connect_sock_t *mp = mp_arg; unix_shared_memory_queue_t *server_q, *client_q; vlib_main_t *vm = vlib_get_main (); f64 timeout = vlib_time_now (vm) + 0.5; @@ -242,7 +243,7 @@ redirect_connect_callback (u32 server_api_client_index, void *mp_arg) { /* correctly enqueued */ case 0: - return VNET_CONNECT_REDIRECTED; + return VNET_API_ERROR_SESSION_REDIRECT; /* continue spinning, wait for pthread_mutex_trylock to work */ case -1: @@ -260,7 +261,7 @@ out: return rv; } -static session_cb_vft_t uri_session_cb_vft = { +static session_cb_vft_t session_cb_vft = { .session_accept_callback = send_session_accept_callback, .session_disconnect_callback = send_session_disconnect_callback, .session_connected_callback = send_session_connected_callback, @@ -285,7 +286,8 @@ vl_api_application_attach_t_handler (vl_api_application_attach_t * mp) { vl_api_application_attach_reply_t *rmp; vnet_app_attach_args_t _a, *a = &_a; - int rv; + clib_error_t *error = 0; + int rv = 0; if (session_manager_is_enabled () == 0) { @@ -298,12 +300,28 @@ vl_api_application_attach_t_handler (vl_api_application_attach_t * mp) "Out of options, fix api message definition"); memset (a, 0, sizeof (*a)); - a->api_client_index = mp->client_index; a->options = mp->options; - a->session_cb_vft = &uri_session_cb_vft; + a->session_cb_vft = &session_cb_vft; - rv = vnet_application_attach (a); + if (mp->namespace_id_len > 64) + { + rv = VNET_API_ERROR_INVALID_VALUE; + goto done; + } + + if (mp->namespace_id_len) + { + vec_validate (a->namespace_id, mp->namespace_id_len); + clib_memcpy (a->namespace_id, mp->namespace_id, mp->namespace_id_len); + } + + if ((error = vnet_application_attach (a))) + { + rv = clib_error_get_code (error); + clib_error_report (error); + } + vec_free (a->namespace_id); done: @@ -312,7 +330,6 @@ done: if (!rv) { rmp->segment_name_length = 0; - /* $$$$ policy? */ rmp->segment_size = a->segment_size; if (a->segment_name_length) { @@ -418,7 +435,8 @@ vl_api_connect_uri_t_handler (vl_api_connect_uri_t * mp) vl_api_connect_session_reply_t *rmp; vnet_connect_args_t _a, *a = &_a; application_t *app; - int rv; + clib_error_t *error = 0; + int rv = 0; if (session_manager_is_enabled () == 0) { @@ -433,14 +451,19 @@ vl_api_connect_uri_t_handler (vl_api_connect_uri_t * mp) a->api_context = mp->context; a->app_index = app->index; a->mp = mp; - rv = vnet_connect_uri (a); + if ((error = vnet_connect_uri (a))) + { + rv = clib_error_get_code (error); + if (rv != VNET_API_ERROR_SESSION_REDIRECT) + clib_error_report (error); + } } else { rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; } - if (rv == 0 || rv == VNET_CONNECT_REDIRECTED) + if (rv == 0 || rv == VNET_API_ERROR_SESSION_REDIRECT) return; /* Got some error, relay it */ @@ -516,7 +539,7 @@ vl_api_reset_session_reply_t_handler (vl_api_reset_session_reply_t * mp) if (!app) return; - stream_session_parse_handle (mp->handle, &index, &thread_index); + session_parse_handle (mp->handle, &index, &thread_index); s = stream_session_get_if_valid (index, thread_index); if (s == 0 || app->index != s->app_index) { @@ -552,7 +575,7 @@ vl_api_accept_session_reply_t_handler (vl_api_accept_session_reply_t * mp) } else { - stream_session_parse_handle (mp->handle, &session_index, &thread_index); + session_parse_handle (mp->handle, &session_index, &thread_index); s = stream_session_get_if_valid (session_index, thread_index); if (!s) { @@ -564,7 +587,6 @@ vl_api_accept_session_reply_t_handler (vl_api_accept_session_reply_t * mp) clib_warning ("app doesn't own session"); return; } - /* XXX volatile? */ s->session_state = SESSION_STATE_READY; } } @@ -581,7 +603,8 @@ vl_api_bind_sock_t_handler (vl_api_bind_sock_t * mp) { vl_api_bind_sock_reply_t *rmp; vnet_bind_args_t _a, *a = &_a; - int rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; + int rv = 0; + clib_error_t *error; application_t *app; if (session_manager_is_enabled () == 0) @@ -594,18 +617,28 @@ vl_api_bind_sock_t_handler (vl_api_bind_sock_t * mp) if (app) { ip46_address_t *ip46 = (ip46_address_t *) mp->ip; - memset (a, 0, sizeof (*a)); - a->tep.is_ip4 = mp->is_ip4; - a->tep.ip = *ip46; - a->tep.port = mp->port; - a->tep.vrf = mp->vrf; + a->sep.is_ip4 = mp->is_ip4; + a->sep.ip = *ip46; + a->sep.port = mp->port; + a->sep.fib_index = mp->vrf; + a->sep.sw_if_index = ENDPOINT_INVALID_INDEX; a->app_index = app->index; + a->proto = mp->proto; - rv = vnet_bind (a); + if ((error = vnet_bind (a))) + { + rv = clib_error_get_code (error); + clib_error_report (error); + } } done: - REPLY_MACRO (VL_API_BIND_SOCK_REPLY); + /* *INDENT-OFF* */ + REPLY_MACRO2 (VL_API_BIND_SOCK_REPLY,({ + if (!rv) + rmp->handle = a->handle; + })); + /* *INDENT-ON* */ } static void @@ -614,7 +647,8 @@ vl_api_unbind_sock_t_handler (vl_api_unbind_sock_t * mp) vl_api_unbind_sock_reply_t *rmp; vnet_unbind_args_t _a, *a = &_a; application_t *app; - int rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; + clib_error_t *error; + int rv = 0; if (session_manager_is_enabled () == 0) { @@ -627,7 +661,11 @@ vl_api_unbind_sock_t_handler (vl_api_unbind_sock_t * mp) { a->app_index = mp->client_index; a->handle = mp->handle; - rv = vnet_unbind (a); + if ((error = vnet_unbind (a))) + { + rv = clib_error_get_code (error); + clib_error_report (error); + } } done: @@ -640,7 +678,8 @@ vl_api_connect_sock_t_handler (vl_api_connect_sock_t * mp) vl_api_connect_session_reply_t *rmp; vnet_connect_args_t _a, *a = &_a; application_t *app; - int rv; + clib_error_t *error = 0; + int rv = 0; if (session_manager_is_enabled () == 0) { @@ -656,22 +695,28 @@ vl_api_connect_sock_t_handler (vl_api_connect_sock_t * mp) client_q = vl_api_client_index_to_input_queue (mp->client_index); mp->client_queue_address = pointer_to_uword (client_q); - a->tep.is_ip4 = mp->is_ip4; - a->tep.ip = *ip46; - a->tep.port = mp->port; - a->tep.vrf = mp->vrf; + a->sep.is_ip4 = mp->is_ip4; + a->sep.ip = *ip46; + a->sep.port = mp->port; + a->sep.transport_proto = mp->proto; + a->sep.fib_index = mp->vrf; + a->sep.sw_if_index = ENDPOINT_INVALID_INDEX; a->api_context = mp->context; a->app_index = app->index; - a->proto = mp->proto; a->mp = mp; - rv = vnet_connect (a); + if ((error = vnet_connect (a))) + { + rv = clib_error_get_code (error); + if (rv != VNET_API_ERROR_SESSION_REDIRECT) + clib_error_report (error); + } } else { rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; } - if (rv == 0 || rv == VNET_CONNECT_REDIRECTED) + if (rv == 0 || rv == VNET_API_ERROR_SESSION_REDIRECT) return; /* Got some error, relay it */ @@ -680,6 +725,46 @@ done: REPLY_MACRO (VL_API_CONNECT_SESSION_REPLY); } +static void +vl_api_app_namespace_add_del_t_handler (vl_api_app_namespace_add_del_t * mp) +{ + vl_api_app_namespace_add_del_reply_t *rmp; + u8 *ns_id = 0; + clib_error_t *error = 0; + int rv = 0; + if (!session_manager_is_enabled ()) + { + rv = VNET_API_ERROR_FEATURE_DISABLED; + goto done; + } + + if (mp->namespace_id_len > ARRAY_LEN (mp->namespace_id)) + { + rv = VNET_API_ERROR_INVALID_VALUE; + goto done; + } + + vec_validate (ns_id, mp->namespace_id_len - 1); + clib_memcpy (ns_id, mp->namespace_id, mp->namespace_id_len); + vnet_app_namespace_add_del_args_t args = { + .ns_id = ns_id, + .secret = mp->secret, + .sw_if_index = clib_net_to_host_u32 (mp->sw_if_index), + .ip4_fib_id = clib_net_to_host_u32 (mp->ip4_fib_id), + .ip6_fib_id = clib_net_to_host_u32 (mp->ip6_fib_id), + .is_add = 1 + }; + error = vnet_app_namespace_add_del (&args); + if (error) + { + rv = clib_error_get_code (error); + clib_error_report (error); + } + vec_free (ns_id); +done: + REPLY_MACRO (VL_API_APP_NAMESPACE_ADD_DEL_REPLY); +} + static clib_error_t * application_reaper_cb (u32 client_index) { diff --git a/src/vnet/session/session_cli.c b/src/vnet/session/session_cli.c index 8c30a1df7eb..588cb603d39 100755 --- a/src/vnet/session/session_cli.c +++ b/src/vnet/session/session_cli.c @@ -138,22 +138,21 @@ unformat_stream_session (unformat_input_t * input, va_list * args) stream_session_t *s; u8 proto = ~0; ip46_address_t lcl, rmt; - u32 lcl_port = 0, rmt_port = 0; - u8 is_ip4 = 0, s_type = ~0; + u32 lcl_port = 0, rmt_port = 0, fib_index = 0; + u8 is_ip4 = 0; if (!unformat (input, "%U", unformat_stream_session_id, &proto, &lcl, &rmt, &lcl_port, &rmt_port, &is_ip4)) return 0; - s_type = session_type_from_proto_and_ip (proto, is_ip4); if (is_ip4) - s = stream_session_lookup4 (&lcl.ip4, &rmt.ip4, - clib_host_to_net_u16 (lcl_port), - clib_host_to_net_u16 (rmt_port), s_type); + s = session_lookup4 (fib_index, &lcl.ip4, &rmt.ip4, + clib_host_to_net_u16 (lcl_port), + clib_host_to_net_u16 (rmt_port), proto); else - s = stream_session_lookup6 (&lcl.ip6, &rmt.ip6, - clib_host_to_net_u16 (lcl_port), - clib_host_to_net_u16 (rmt_port), s_type); + s = session_lookup6 (fib_index, &lcl.ip6, &rmt.ip6, + clib_host_to_net_u16 (lcl_port), + clib_host_to_net_u16 (rmt_port), proto); if (s) { *result = s; @@ -170,8 +169,8 @@ unformat_transport_connection (unformat_input_t * input, va_list * args) transport_connection_t *tc; u8 proto = ~0; ip46_address_t lcl, rmt; - u32 lcl_port = 0, rmt_port = 0; - u8 is_ip4 = 0, s_type = ~0; + u32 lcl_port = 0, rmt_port = 0, fib_index = 0; + u8 is_ip4 = 0; if (!unformat (input, "%U", unformat_stream_session_id, &proto, &lcl, &rmt, &lcl_port, &rmt_port, &is_ip4)) @@ -180,17 +179,14 @@ unformat_transport_connection (unformat_input_t * input, va_list * args) proto = (proto == (u8) ~ 0) ? suggested_proto : proto; if (proto == (u8) ~ 0) return 0; - s_type = session_type_from_proto_and_ip (proto, is_ip4); if (is_ip4) - tc = stream_session_lookup_transport4 (&lcl.ip4, &rmt.ip4, - clib_host_to_net_u16 (lcl_port), - clib_host_to_net_u16 (rmt_port), - s_type); + tc = session_lookup_connection4 (fib_index, &lcl.ip4, &rmt.ip4, + clib_host_to_net_u16 (lcl_port), + clib_host_to_net_u16 (rmt_port), proto); else - tc = stream_session_lookup_transport6 (&lcl.ip6, &rmt.ip6, - clib_host_to_net_u16 (lcl_port), - clib_host_to_net_u16 (rmt_port), - s_type); + tc = session_lookup_connection6 (fib_index, &lcl.ip6, &rmt.ip6, + clib_host_to_net_u16 (lcl_port), + clib_host_to_net_u16 (rmt_port), proto); if (tc) { diff --git a/src/vnet/session/session_debug.h b/src/vnet/session/session_debug.h index eb11f1a00b9..d9b71035314 100644 --- a/src/vnet/session/session_debug.h +++ b/src/vnet/session/session_debug.h @@ -31,11 +31,13 @@ typedef enum _session_evt_dbg #undef _ } session_evt_dbg_e; -#define SESSION_DBG (0) +#define SESSION_DEBUG (0 && TRANSPORT_DEBUG) #define SESSION_DEQ_NODE_EVTS (0) #define SESSION_EVT_POLL_DBG (1) -#if TRANSPORT_DEBUG && SESSION_DBG +#if SESSION_DEBUG + +#define SESSION_DBG(_fmt, _args...) clib_warning (_fmt, ##_args) #define DEC_SESSION_ETD(_s, _e, _size) \ struct \ @@ -78,7 +80,7 @@ typedef enum _session_evt_dbg do { _body; } while (0); \ } -#if SESSION_DEQ_NODE_EVTS +#if SESSION_DEQ_NODE_EVTS && SESSION_DEBUG > 1 #define SESSION_EVT_DEQ_NODE_HANDLER(_node_evt) \ { \ ELOG_TYPE_DECLARE (_e) = \ @@ -96,9 +98,9 @@ typedef enum _session_evt_dbg } #else #define SESSION_EVT_DEQ_NODE_HANDLER(_node_evt) -#endif +#endif /* SESSION_DEQ_NODE_EVTS */ -#if SESSION_DBG && SESSION_EVT_POLL_DBG +#if SESSION_EVT_POLL_DBG && SESSION_DEBUG > 1 #define SESSION_EVT_POLL_GAP(_smm, _my_thread_index) \ { \ ELOG_TYPE_DECLARE (_e) = \ @@ -122,7 +124,7 @@ typedef enum _session_evt_dbg #else #define SESSION_EVT_POLL_GAP(_smm, _my_thread_index) #define SESSION_EVT_POLL_GAP_TRACK_HANDLER(_smm, _my_thread_index) -#endif +#endif /* SESSION_EVT_POLL_DBG */ #define CONCAT_HELPER(_a, _b) _a##_b #define CC(_a, _b) CONCAT_HELPER(_a, _b) @@ -130,7 +132,8 @@ typedef enum _session_evt_dbg #else #define SESSION_EVT_DBG(_evt, _args...) -#endif +#define SESSION_DBG(_fmt, _args...) +#endif /* SESSION_DEBUG */ #endif /* SRC_VNET_SESSION_SESSION_DEBUG_H_ */ /* diff --git a/src/vnet/session/session_lookup.c b/src/vnet/session/session_lookup.c index 4487b1c305f..796d93ec33e 100644 --- a/src/vnet/session/session_lookup.c +++ b/src/vnet/session/session_lookup.c @@ -27,10 +27,19 @@ #include <vppinfra/bihash_template.c> #include <vnet/session/session_lookup.h> #include <vnet/session/session.h> +#include <vnet/session/application.h> -static session_lookup_t session_lookup; +/** + * External vector of per transport virtual functions table + */ extern transport_proto_vft_t *tp_vfts; +/** + * Network namespace index (i.e., fib index) to session lookup table. We + * should have one per network protocol type but for now we only support IP4/6 + */ +static u32 *fib_index_to_table_index[2]; + /* *INDENT-OFF* */ /* 16 octets */ typedef CLIB_PACKED (struct { @@ -153,461 +162,859 @@ make_v6_ss_kv_from_tc (session_kv6_t * kv, transport_connection_t * t) session_type_from_proto_and_ip (t->transport_proto, 0)); } -/* - * Session lookup key; (src-ip, dst-ip, src-port, dst-port, session-type) - * Value: (owner thread index << 32 | session_index); + +static session_table_t * +session_table_get_or_alloc_for_connection (transport_connection_t * tc) +{ + session_table_t *st; + u32 table_index, fib_proto = transport_connection_fib_proto (tc); + if (vec_len (fib_index_to_table_index[fib_proto]) <= tc->fib_index) + { + st = session_table_alloc (); + table_index = session_table_index (st); + vec_validate (fib_index_to_table_index[fib_proto], tc->fib_index); + fib_index_to_table_index[fib_proto][tc->fib_index] = table_index; + return st; + } + else + { + table_index = fib_index_to_table_index[fib_proto][tc->fib_index]; + return session_table_get (table_index); + } +} + +static session_table_t * +session_table_get_for_connection (transport_connection_t * tc) +{ + u32 fib_proto = transport_connection_fib_proto (tc); + if (vec_len (fib_index_to_table_index[fib_proto]) <= tc->fib_index) + return 0; + return + session_table_get (fib_index_to_table_index[fib_proto][tc->fib_index]); +} + +static session_table_t * +session_table_get_for_fib_index (u32 fib_proto, u32 fib_index) +{ + if (vec_len (fib_index_to_table_index[fib_proto]) <= fib_index) + return 0; + return session_table_get (fib_index_to_table_index[fib_proto][fib_index]); +} + +u32 +session_lookup_get_index_for_fib (u32 fib_proto, u32 fib_index) +{ + if (vec_len (fib_index_to_table_index[fib_proto]) <= fib_index) + return SESSION_TABLE_INVALID_INDEX; + return fib_index_to_table_index[fib_proto][fib_index]; +} + +/** + * Add transport connection to a session table + * + * Session lookup 5-tuple (src-ip, dst-ip, src-port, dst-port, session-type) + * is added to requested session table. + * + * @param tc transport connection to be added + * @param value value to be stored + * + * @return non-zero if failure */ -void -stream_session_table_add_for_tc (transport_connection_t * tc, u64 value) +int +session_lookup_add_connection (transport_connection_t * tc, u64 value) { - session_lookup_t *sl = &session_lookup; + session_table_t *st; session_kv4_t kv4; session_kv6_t kv6; + st = session_table_get_or_alloc_for_connection (tc); + if (!st) + return -1; if (tc->is_ip4) { make_v4_ss_kv_from_tc (&kv4, tc); kv4.value = value; - clib_bihash_add_del_16_8 (&sl->v4_session_hash, &kv4, 1 /* is_add */ ); + return clib_bihash_add_del_16_8 (&st->v4_session_hash, &kv4, + 1 /* is_add */ ); } else { make_v6_ss_kv_from_tc (&kv6, tc); kv6.value = value; - clib_bihash_add_del_48_8 (&sl->v6_session_hash, &kv6, 1 /* is_add */ ); + return clib_bihash_add_del_48_8 (&st->v6_session_hash, &kv6, + 1 /* is_add */ ); } } -void -stream_session_table_add (session_manager_main_t * smm, stream_session_t * s, - u64 value) +int +session_lookup_add_session_endpoint (u32 table_index, + session_endpoint_t * sep, u64 value) { - transport_connection_t *tc; + session_table_t *st; + session_kv4_t kv4; + session_kv6_t kv6; - tc = tp_vfts[s->session_type].get_connection (s->connection_index, - s->thread_index); - stream_session_table_add_for_tc (tc, value); + st = session_table_get (table_index); + if (!st) + return -1; + if (sep->is_ip4) + { + make_v4_listener_kv (&kv4, &sep->ip.ip4, sep->port, + sep->transport_proto); + kv4.value = value; + return clib_bihash_add_del_16_8 (&st->v4_session_hash, &kv4, 1); + } + else + { + make_v6_listener_kv (&kv6, &sep->ip.ip6, sep->port, + sep->transport_proto); + kv6.value = value; + return clib_bihash_add_del_48_8 (&st->v6_session_hash, &kv6, 1); + } } int -stream_session_table_del_for_tc (transport_connection_t * tc) +session_lookup_del_session_endpoint (u32 table_index, + session_endpoint_t * sep) { - session_lookup_t *sl = &session_lookup; + session_table_t *st; session_kv4_t kv4; session_kv6_t kv6; + st = session_table_get (table_index); + if (!st) + return -1; + if (sep->is_ip4) + { + make_v4_listener_kv (&kv4, &sep->ip.ip4, sep->port, + sep->transport_proto); + return clib_bihash_add_del_16_8 (&st->v4_session_hash, &kv4, 0); + } + else + { + make_v6_listener_kv (&kv6, &sep->ip.ip6, sep->port, + sep->transport_proto); + return clib_bihash_add_del_48_8 (&st->v6_session_hash, &kv6, 0); + } +} + +/** + * Delete transport connection from session table + * + * @param table_index session table index + * @param tc transport connection to be removed + * + * @return non-zero if failure + */ +int +session_lookup_del_connection (transport_connection_t * tc) +{ + session_table_t *st; + session_kv4_t kv4; + session_kv6_t kv6; + + st = session_table_get_for_connection (tc); + if (!st) + return -1; if (tc->is_ip4) { make_v4_ss_kv_from_tc (&kv4, tc); - return clib_bihash_add_del_16_8 (&sl->v4_session_hash, &kv4, + return clib_bihash_add_del_16_8 (&st->v4_session_hash, &kv4, 0 /* is_add */ ); } else { make_v6_ss_kv_from_tc (&kv6, tc); - return clib_bihash_add_del_48_8 (&sl->v6_session_hash, &kv6, + return clib_bihash_add_del_48_8 (&st->v6_session_hash, &kv6, 0 /* is_add */ ); } - - return 0; } int -stream_session_table_del (stream_session_t * s) +session_lookup_del_session (stream_session_t * s) { transport_connection_t *ts; ts = tp_vfts[s->session_type].get_connection (s->connection_index, s->thread_index); - return stream_session_table_del_for_tc (ts); + return session_lookup_del_connection (ts); } - -void -stream_session_half_open_table_add (transport_connection_t * tc, u64 value) +u32 +session_lookup_session_endpoint (u32 table_index, session_endpoint_t * sep) { - session_lookup_t *sl = &session_lookup; + session_table_t *st; session_kv4_t kv4; session_kv6_t kv6; + int rv; - if (tc->is_ip4) + st = session_table_get (table_index); + if (!st) + return SESSION_INVALID_INDEX; + if (sep->is_ip4) { - make_v4_ss_kv_from_tc (&kv4, tc); - kv4.value = value; - (void) clib_bihash_add_del_16_8 (&sl->v4_half_open_hash, &kv4, - 1 /* is_add */ ); + make_v4_listener_kv (&kv4, &sep->ip.ip4, sep->port, + sep->transport_proto); + rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4); + if (rv == 0) + return (u32) kv4.value; } else { - make_v6_ss_kv_from_tc (&kv6, tc); - kv6.value = value; - (void) clib_bihash_add_del_48_8 (&sl->v6_half_open_hash, &kv6, - 1 /* is_add */ ); + make_v6_listener_kv (&kv6, &sep->ip.ip6, sep->port, + sep->transport_proto); + rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6); + if (rv == 0) + return (u32) kv6.value; } + return SESSION_INVALID_INDEX; } -void -stream_session_half_open_table_del (transport_connection_t * tc) +u32 +session_lookup_local_session_endpoint (u32 table_index, + session_endpoint_t * sep) { - session_lookup_t *sl = &session_lookup; + session_table_t *st; session_kv4_t kv4; session_kv6_t kv6; + int rv; - if (tc->is_ip4) + st = session_table_get (table_index); + if (!st) + return SESSION_INVALID_INDEX; + if (sep->is_ip4) { - make_v4_ss_kv_from_tc (&kv4, tc); - clib_bihash_add_del_16_8 (&sl->v4_half_open_hash, &kv4, - 0 /* is_add */ ); + make_v4_listener_kv (&kv4, &sep->ip.ip4, sep->port, + sep->transport_proto); + rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4); + if (rv == 0) + return (u32) kv4.value; + + /* + * Zero out the ip. Logic is that connect to local ips, say + * 127.0.0.1:port, can match 0.0.0.0:port + */ + kv4.key[0] = 0; + rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4); + if (rv == 0) + return (u32) kv4.value; } else { - make_v6_ss_kv_from_tc (&kv6, tc); - clib_bihash_add_del_48_8 (&sl->v6_half_open_hash, &kv6, - 0 /* is_add */ ); + make_v6_listener_kv (&kv6, &sep->ip.ip6, sep->port, + sep->transport_proto); + rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6); + if (rv == 0) + return (u32) kv6.value; + + /* + * Zero out the ip. Same logic as above. + */ + kv6.key[0] = kv6.key[1] = 0; + rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6); + if (rv == 0) + return (u32) kv6.value; } + return SESSION_INVALID_INDEX; } -stream_session_t * -stream_session_lookup_listener4 (ip4_address_t * lcl, u16 lcl_port, u8 proto) +static stream_session_t * +session_lookup_listener4_i (session_table_t * st, ip4_address_t * lcl, + u16 lcl_port, u8 proto) { - session_lookup_t *sl = &session_lookup; session_kv4_t kv4; int rv; make_v4_listener_kv (&kv4, lcl, lcl_port, proto); - rv = clib_bihash_search_inline_16_8 (&sl->v4_session_hash, &kv4); + rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4); if (rv == 0) return session_manager_get_listener (proto, (u32) kv4.value); /* Zero out the lcl ip */ kv4.key[0] = 0; - rv = clib_bihash_search_inline_16_8 (&sl->v4_session_hash, &kv4); + rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4); if (rv == 0) return session_manager_get_listener (proto, (u32) kv4.value); return 0; } -/** Looks up a session based on the 5-tuple passed as argument. - * - * First it tries to find an established session, if this fails, it tries - * finding a listener session if this fails, it tries a lookup with a - * wildcarded local source (listener bound to all interfaces) - */ stream_session_t * -stream_session_lookup4 (ip4_address_t * lcl, ip4_address_t * rmt, - u16 lcl_port, u16 rmt_port, u8 proto) +session_lookup_listener4 (u32 fib_index, ip4_address_t * lcl, u16 lcl_port, + u8 proto) { - session_lookup_t *sl = &session_lookup; - session_kv4_t kv4; - stream_session_t *s; - int rv; - - /* Lookup session amongst established ones */ - make_v4_ss_kv (&kv4, lcl, rmt, lcl_port, rmt_port, proto); - rv = clib_bihash_search_inline_16_8 (&sl->v4_session_hash, &kv4); - if (rv == 0) - return stream_session_get_from_handle (kv4.value); - - /* If nothing is found, check if any listener is available */ - if ((s = stream_session_lookup_listener4 (lcl, lcl_port, proto))) - return s; - - /* Finally, try half-open connections */ - rv = clib_bihash_search_inline_16_8 (&sl->v4_half_open_hash, &kv4); - if (rv == 0) - return stream_session_get_from_handle (kv4.value); - return 0; + session_table_t *st; + st = session_table_get_for_fib_index (FIB_PROTOCOL_IP4, fib_index); + if (!st) + return 0; + return session_lookup_listener4_i (st, lcl, lcl_port, proto); } -stream_session_t * -stream_session_lookup_listener6 (ip6_address_t * lcl, u16 lcl_port, u8 proto) +static stream_session_t * +session_lookup_listener6_i (session_table_t * st, ip6_address_t * lcl, + u16 lcl_port, u8 proto) { - session_lookup_t *sl = &session_lookup; session_kv6_t kv6; int rv; make_v6_listener_kv (&kv6, lcl, lcl_port, proto); - rv = clib_bihash_search_inline_48_8 (&sl->v6_session_hash, &kv6); + rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6); if (rv == 0) return session_manager_get_listener (proto, (u32) kv6.value); /* Zero out the lcl ip */ kv6.key[0] = kv6.key[1] = 0; - rv = clib_bihash_search_inline_48_8 (&sl->v6_session_hash, &kv6); + rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6); if (rv == 0) return session_manager_get_listener (proto, (u32) kv6.value); return 0; } -/* Looks up a session based on the 5-tuple passed as argument. - * First it tries to find an established session, if this fails, it tries - * finding a listener session if this fails, it tries a lookup with a - * wildcarded local source (listener bound to all interfaces) */ stream_session_t * -stream_session_lookup6 (ip6_address_t * lcl, ip6_address_t * rmt, - u16 lcl_port, u16 rmt_port, u8 proto) +session_lookup_listener6 (u32 fib_index, ip6_address_t * lcl, u16 lcl_port, + u8 proto) { - session_lookup_t *sl = &session_lookup; - session_kv6_t kv6; - stream_session_t *s; - int rv; + session_table_t *st; + st = session_table_get_for_fib_index (FIB_PROTOCOL_IP6, fib_index); + if (!st) + return 0; + return session_lookup_listener6_i (st, lcl, lcl_port, proto); +} - make_v6_ss_kv (&kv6, lcl, rmt, lcl_port, rmt_port, proto); - rv = clib_bihash_search_inline_48_8 (&sl->v6_session_hash, &kv6); - if (rv == 0) - return stream_session_get_from_handle (kv6.value); +stream_session_t * +session_lookup_listener (u32 table_index, session_endpoint_t * sep) +{ + session_table_t *st; + st = session_table_get (table_index); + if (!st) + return 0; + if (sep->is_ip4) + return session_lookup_listener4_i (st, &sep->ip.ip4, sep->port, + sep->transport_proto); + else + return session_lookup_listener6_i (st, &sep->ip.ip6, sep->port, + sep->transport_proto); + return 0; +} - /* If nothing is found, check if any listener is available */ - if ((s = stream_session_lookup_listener6 (lcl, lcl_port, proto))) - return s; +int +session_lookup_add_half_open (transport_connection_t * tc, u64 value) +{ + session_table_t *st; + session_kv4_t kv4; + session_kv6_t kv6; - /* Finally, try half-open connections */ - rv = clib_bihash_search_inline_48_8 (&sl->v6_half_open_hash, &kv6); - if (rv == 0) - return stream_session_get_from_handle (kv6.value); - return 0; + st = session_table_get_or_alloc_for_connection (tc); + if (!st) + return 0; + if (tc->is_ip4) + { + make_v4_ss_kv_from_tc (&kv4, tc); + kv4.value = value; + return clib_bihash_add_del_16_8 (&st->v4_half_open_hash, &kv4, + 1 /* is_add */ ); + } + else + { + make_v6_ss_kv_from_tc (&kv6, tc); + kv6.value = value; + return clib_bihash_add_del_48_8 (&st->v6_half_open_hash, &kv6, + 1 /* is_add */ ); + } } -stream_session_t * -stream_session_lookup_listener (ip46_address_t * lcl, u16 lcl_port, u8 proto) +int +session_lookup_del_half_open (transport_connection_t * tc) { - switch (proto) + session_table_t *st; + session_kv4_t kv4; + session_kv6_t kv6; + + st = session_table_get_for_connection (tc); + if (!st) + return -1; + if (tc->is_ip4) { - case SESSION_TYPE_IP4_UDP: - case SESSION_TYPE_IP4_TCP: - return stream_session_lookup_listener4 (&lcl->ip4, lcl_port, proto); - break; - case SESSION_TYPE_IP6_UDP: - case SESSION_TYPE_IP6_TCP: - return stream_session_lookup_listener6 (&lcl->ip6, lcl_port, proto); - break; + make_v4_ss_kv_from_tc (&kv4, tc); + return clib_bihash_add_del_16_8 (&st->v4_half_open_hash, &kv4, + 0 /* is_add */ ); + } + else + { + make_v6_ss_kv_from_tc (&kv6, tc); + return clib_bihash_add_del_48_8 (&st->v6_half_open_hash, &kv6, + 0 /* is_add */ ); } - return 0; } u64 -stream_session_half_open_lookup_handle (ip46_address_t * lcl, - ip46_address_t * rmt, u16 lcl_port, - u16 rmt_port, u8 proto) +session_lookup_half_open_handle (transport_connection_t * tc) { - session_lookup_t *sl = &session_lookup; + session_table_t *st; session_kv4_t kv4; session_kv6_t kv6; int rv; - switch (proto) + st = session_table_get_for_fib_index (transport_connection_fib_proto (tc), + tc->fib_index); + if (!st) + return HALF_OPEN_LOOKUP_INVALID_VALUE; + if (tc->is_ip4) { - case SESSION_TYPE_IP4_UDP: - case SESSION_TYPE_IP4_TCP: - make_v4_ss_kv (&kv4, &lcl->ip4, &rmt->ip4, lcl_port, rmt_port, proto); - rv = clib_bihash_search_inline_16_8 (&sl->v4_half_open_hash, &kv4); - + make_v4_ss_kv (&kv4, &tc->lcl_ip.ip4, &tc->rmt_ip.ip4, tc->lcl_port, + tc->rmt_port, tc->transport_proto); + rv = clib_bihash_search_inline_16_8 (&st->v4_half_open_hash, &kv4); if (rv == 0) return kv4.value; - - return HALF_OPEN_LOOKUP_INVALID_VALUE; - break; - case SESSION_TYPE_IP6_UDP: - case SESSION_TYPE_IP6_TCP: - make_v6_ss_kv (&kv6, &lcl->ip6, &rmt->ip6, lcl_port, rmt_port, proto); - rv = clib_bihash_search_inline_48_8 (&sl->v6_half_open_hash, &kv6); - + } + else + { + make_v6_ss_kv (&kv6, &tc->lcl_ip.ip6, &tc->rmt_ip.ip6, tc->lcl_port, + tc->rmt_port, tc->transport_proto); + rv = clib_bihash_search_inline_48_8 (&st->v6_half_open_hash, &kv6); if (rv == 0) return kv6.value; - - return HALF_OPEN_LOOKUP_INVALID_VALUE; - break; } return HALF_OPEN_LOOKUP_INVALID_VALUE; } transport_connection_t * -stream_session_half_open_lookup (ip46_address_t * lcl, ip46_address_t * rmt, - u16 lcl_port, u16 rmt_port, u8 proto) +session_lookup_half_open_connection (u64 handle, u8 proto, u8 is_ip4) { - u64 handle; - handle = - stream_session_half_open_lookup_handle (lcl, rmt, lcl_port, rmt_port, - proto); + u32 sst; + if (handle != HALF_OPEN_LOOKUP_INVALID_VALUE) - return tp_vfts[proto].get_half_open (handle & 0xFFFFFFFF); + { + sst = session_type_from_proto_and_ip (proto, is_ip4); + return tp_vfts[sst].get_half_open (handle & 0xFFFFFFFF); + } return 0; } -always_inline stream_session_t * -stream_session_get_tsi (u64 ti_and_si, u32 thread_index) -{ - ASSERT ((u32) (ti_and_si >> 32) == thread_index); - return pool_elt_at_index (session_manager_main.sessions[thread_index], - ti_and_si & 0xFFFFFFFFULL); -} - +/** + * Lookup connection with ip4 and transport layer information + * + * This is used on the fast path so it needs to be fast. Thereby, + * duplication of code and 'hacks' allowed. + * + * The lookup is incremental and returns whenever something is matched. The + * steps are: + * - Try to find an established session + * - Try to find a fully-formed or local source wildcarded (listener bound to + * all interfaces) listener session + * - Try to find a half-open connection + * - return 0 + * + * @param fib_index index of fib wherein the connection was received + * @param lcl local ip4 address + * @param rmt remote ip4 address + * @param lcl_port local port + * @param rmt_port remote port + * @param proto transport protocol (e.g., tcp, udp) + * @param thread_index thread index for request + * + * @return pointer to transport connection, if one is found, 0 otherwise + */ transport_connection_t * -stream_session_lookup_transport_wt4 (ip4_address_t * lcl, ip4_address_t * rmt, - u16 lcl_port, u16 rmt_port, u8 proto, - u32 my_thread_index) +session_lookup_connection_wt4 (u32 fib_index, ip4_address_t * lcl, + ip4_address_t * rmt, u16 lcl_port, + u16 rmt_port, u8 proto, u32 thread_index) { - session_lookup_t *sl = &session_lookup; + session_table_t *st; session_kv4_t kv4; stream_session_t *s; int rv; + st = session_table_get_for_fib_index (FIB_PROTOCOL_IP4, fib_index); + if (PREDICT_FALSE (!st)) + return 0; + /* Lookup session amongst established ones */ make_v4_ss_kv (&kv4, lcl, rmt, lcl_port, rmt_port, proto); - rv = clib_bihash_search_inline_16_8 (&sl->v4_session_hash, &kv4); + rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4); if (rv == 0) { - s = stream_session_get_tsi (kv4.value, my_thread_index); + ASSERT ((u32) (kv4.value >> 32) == thread_index); + s = session_get (kv4.value & 0xFFFFFFFFULL, thread_index); return tp_vfts[s->session_type].get_connection (s->connection_index, - my_thread_index); + thread_index); } /* If nothing is found, check if any listener is available */ - s = stream_session_lookup_listener4 (lcl, lcl_port, proto); + s = session_lookup_listener4_i (st, lcl, lcl_port, proto); if (s) return tp_vfts[s->session_type].get_listener (s->connection_index); /* Finally, try half-open connections */ - rv = clib_bihash_search_inline_16_8 (&sl->v4_half_open_hash, &kv4); + rv = clib_bihash_search_inline_16_8 (&st->v4_half_open_hash, &kv4); if (rv == 0) - return tp_vfts[proto].get_half_open (kv4.value & 0xFFFFFFFF); + { + u32 sst = session_type_from_proto_and_ip (proto, 1); + return tp_vfts[sst].get_half_open (kv4.value & 0xFFFFFFFF); + } return 0; } +/** + * Lookup connection with ip4 and transport layer information + * + * Not optimized. This is used on the fast path so it needs to be fast. + * Thereby, duplication of code and 'hacks' allowed. Lookup logic is identical + * to that of @ref session_lookup_connection_wt4 + * + * @param fib_index index of the fib wherein the connection was received + * @param lcl local ip4 address + * @param rmt remote ip4 address + * @param lcl_port local port + * @param rmt_port remote port + * @param proto transport protocol (e.g., tcp, udp) + * + * @return pointer to transport connection, if one is found, 0 otherwise + */ transport_connection_t * -stream_session_lookup_transport4 (ip4_address_t * lcl, ip4_address_t * rmt, - u16 lcl_port, u16 rmt_port, u8 proto) +session_lookup_connection4 (u32 fib_index, ip4_address_t * lcl, + ip4_address_t * rmt, u16 lcl_port, u16 rmt_port, + u8 proto) { - session_lookup_t *sl = &session_lookup; + session_table_t *st; session_kv4_t kv4; stream_session_t *s; int rv; + st = session_table_get_for_fib_index (FIB_PROTOCOL_IP4, fib_index); + if (PREDICT_FALSE (!st)) + return 0; + /* Lookup session amongst established ones */ make_v4_ss_kv (&kv4, lcl, rmt, lcl_port, rmt_port, proto); - rv = clib_bihash_search_inline_16_8 (&sl->v4_session_hash, &kv4); + rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4); if (rv == 0) { - s = stream_session_get_from_handle (kv4.value); + s = session_get_from_handle (kv4.value); return tp_vfts[s->session_type].get_connection (s->connection_index, s->thread_index); } /* If nothing is found, check if any listener is available */ - s = stream_session_lookup_listener4 (lcl, lcl_port, proto); + s = session_lookup_listener4_i (st, lcl, lcl_port, proto); if (s) return tp_vfts[s->session_type].get_listener (s->connection_index); /* Finally, try half-open connections */ - rv = clib_bihash_search_inline_16_8 (&sl->v4_half_open_hash, &kv4); + rv = clib_bihash_search_inline_16_8 (&st->v4_half_open_hash, &kv4); if (rv == 0) - return tp_vfts[proto].get_half_open (kv4.value & 0xFFFFFFFF); + { + u32 sst = session_type_from_proto_and_ip (proto, 1); + return tp_vfts[sst].get_half_open (kv4.value & 0xFFFFFFFF); + } return 0; } +/** + * Lookup session with ip4 and transport layer information + * + * Lookup logic is identical to that of @ref session_lookup_connection_wt4 but + * this returns a session as opposed to a transport connection; + */ +stream_session_t * +session_lookup4 (u32 fib_index, ip4_address_t * lcl, ip4_address_t * rmt, + u16 lcl_port, u16 rmt_port, u8 proto) +{ + session_table_t *st; + session_kv4_t kv4; + stream_session_t *s; + int rv; + + st = session_table_get_for_fib_index (FIB_PROTOCOL_IP4, fib_index); + if (PREDICT_FALSE (!st)) + return 0; + + /* Lookup session amongst established ones */ + make_v4_ss_kv (&kv4, lcl, rmt, lcl_port, rmt_port, proto); + rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4); + if (rv == 0) + return session_get_from_handle (kv4.value); + + /* If nothing is found, check if any listener is available */ + if ((s = session_lookup_listener4_i (st, lcl, lcl_port, proto))) + return s; + + /* Finally, try half-open connections */ + rv = clib_bihash_search_inline_16_8 (&st->v4_half_open_hash, &kv4); + if (rv == 0) + return session_get_from_handle (kv4.value); + return 0; +} + +/** + * Lookup connection with ip6 and transport layer information + * + * This is used on the fast path so it needs to be fast. Thereby, + * duplication of code and 'hacks' allowed. + * + * The lookup is incremental and returns whenever something is matched. The + * steps are: + * - Try to find an established session + * - Try to find a fully-formed or local source wildcarded (listener bound to + * all interfaces) listener session + * - Try to find a half-open connection + * - return 0 + * + * @param fib_index index of the fib wherein the connection was received + * @param lcl local ip6 address + * @param rmt remote ip6 address + * @param lcl_port local port + * @param rmt_port remote port + * @param proto transport protocol (e.g., tcp, udp) + * @param thread_index thread index for request + * + * @return pointer to transport connection, if one is found, 0 otherwise + */ transport_connection_t * -stream_session_lookup_transport_wt6 (ip6_address_t * lcl, ip6_address_t * rmt, - u16 lcl_port, u16 rmt_port, u8 proto, - u32 my_thread_index) +session_lookup_connection_wt6 (u32 fib_index, ip6_address_t * lcl, + ip6_address_t * rmt, u16 lcl_port, + u16 rmt_port, u8 proto, u32 thread_index) { - session_lookup_t *sl = &session_lookup; + session_table_t *st; stream_session_t *s; session_kv6_t kv6; int rv; + st = session_table_get_for_fib_index (FIB_PROTOCOL_IP6, fib_index); + if (PREDICT_FALSE (!st)) + return 0; + make_v6_ss_kv (&kv6, lcl, rmt, lcl_port, rmt_port, proto); - rv = clib_bihash_search_inline_48_8 (&sl->v6_session_hash, &kv6); + rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6); if (rv == 0) { - s = stream_session_get_tsi (kv6.value, my_thread_index); + ASSERT ((u32) (kv6.value >> 32) == thread_index); + s = session_get (kv6.value & 0xFFFFFFFFULL, thread_index); return tp_vfts[s->session_type].get_connection (s->connection_index, - my_thread_index); + thread_index); } /* If nothing is found, check if any listener is available */ - s = stream_session_lookup_listener6 (lcl, lcl_port, proto); + s = session_lookup_listener6_i (st, lcl, lcl_port, proto); if (s) return tp_vfts[s->session_type].get_listener (s->connection_index); /* Finally, try half-open connections */ - rv = clib_bihash_search_inline_48_8 (&sl->v6_half_open_hash, &kv6); + rv = clib_bihash_search_inline_48_8 (&st->v6_half_open_hash, &kv6); if (rv == 0) - return tp_vfts[proto].get_half_open (kv6.value & 0xFFFFFFFF); + { + u32 sst = session_type_from_proto_and_ip (proto, 1); + return tp_vfts[sst].get_half_open (kv6.value & 0xFFFFFFFF); + } return 0; } +/** + * Lookup connection with ip6 and transport layer information + * + * Not optimized. This is used on the fast path so it needs to be fast. + * Thereby, duplication of code and 'hacks' allowed. Lookup logic is identical + * to that of @ref session_lookup_connection_wt4 + * + * @param fib_index index of the fib wherein the connection was received + * @param lcl local ip6 address + * @param rmt remote ip6 address + * @param lcl_port local port + * @param rmt_port remote port + * @param proto transport protocol (e.g., tcp, udp) + * + * @return pointer to transport connection, if one is found, 0 otherwise + */ transport_connection_t * -stream_session_lookup_transport6 (ip6_address_t * lcl, ip6_address_t * rmt, - u16 lcl_port, u16 rmt_port, u8 proto) +session_lookup_connection6 (u32 fib_index, ip6_address_t * lcl, + ip6_address_t * rmt, u16 lcl_port, u16 rmt_port, + u8 proto) { - session_lookup_t *sl = &session_lookup; + session_table_t *st; stream_session_t *s; session_kv6_t kv6; int rv; + st = session_table_get_for_fib_index (FIB_PROTOCOL_IP6, fib_index); + if (PREDICT_FALSE (!st)) + return 0; + make_v6_ss_kv (&kv6, lcl, rmt, lcl_port, rmt_port, proto); - rv = clib_bihash_search_inline_48_8 (&sl->v6_session_hash, &kv6); + rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6); if (rv == 0) { - s = stream_session_get_from_handle (kv6.value); + s = session_get_from_handle (kv6.value); return tp_vfts[s->session_type].get_connection (s->connection_index, s->thread_index); } /* If nothing is found, check if any listener is available */ - s = stream_session_lookup_listener6 (lcl, lcl_port, proto); + s = session_lookup_listener6 (fib_index, lcl, lcl_port, proto); if (s) return tp_vfts[s->session_type].get_listener (s->connection_index); /* Finally, try half-open connections */ - rv = clib_bihash_search_inline_48_8 (&sl->v6_half_open_hash, &kv6); + rv = clib_bihash_search_inline_48_8 (&st->v6_half_open_hash, &kv6); + if (rv == 0) + { + u32 sst = session_type_from_proto_and_ip (proto, 1); + return tp_vfts[sst].get_half_open (kv6.value & 0xFFFFFFFF); + } + + return 0; +} + +/** + * Lookup session with ip6 and transport layer information + * + * Lookup logic is identical to that of @ref session_lookup_connection_wt6 but + * this returns a session as opposed to a transport connection; + */ +stream_session_t * +session_lookup6 (u32 fib_index, ip6_address_t * lcl, ip6_address_t * rmt, + u16 lcl_port, u16 rmt_port, u8 proto) +{ + session_table_t *st; + session_kv6_t kv6; + stream_session_t *s; + int rv; + + st = session_table_get_for_fib_index (FIB_PROTOCOL_IP6, fib_index); + if (PREDICT_FALSE (!st)) + return 0; + + make_v6_ss_kv (&kv6, lcl, rmt, lcl_port, rmt_port, proto); + rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6); + if (rv == 0) + return session_get_from_handle (kv6.value); + + /* If nothing is found, check if any listener is available */ + if ((s = session_lookup_listener6_i (st, lcl, lcl_port, proto))) + return s; + + /* Finally, try half-open connections */ + rv = clib_bihash_search_inline_48_8 (&st->v6_half_open_hash, &kv6); if (rv == 0) - return tp_vfts[proto].get_half_open (kv6.value & 0xFFFFFFFF); + return session_get_from_handle (kv6.value); + return 0; +} +u64 +session_lookup_local_listener_make_handle (session_endpoint_t * sep) +{ + return ((u64) SESSION_LOCAL_TABLE_PREFIX << 32 + | (u32) sep->port << 16 | (u32) sep->transport_proto << 8 + | (u32) sep->is_ip4); +} + +u8 +session_lookup_local_is_handle (u64 handle) +{ + if (handle >> 32 == SESSION_LOCAL_TABLE_PREFIX) + return 1; return 0; } -#define foreach_hash_table_parameter \ - _(v4,session,buckets,20000) \ - _(v4,session,memory,(64<<20)) \ - _(v6,session,buckets,20000) \ - _(v6,session,memory,(64<<20)) \ - _(v4,halfopen,buckets,20000) \ - _(v4,halfopen,memory,(64<<20)) \ - _(v6,halfopen,buckets,20000) \ - _(v6,halfopen,memory,(64<<20)) +int +session_lookup_local_listener_parse_handle (u64 handle, + session_endpoint_t * sep) +{ + u32 local_table_handle; + if (handle >> 32 != SESSION_LOCAL_TABLE_PREFIX) + return -1; + local_table_handle = handle & 0xFFFFFFFFULL; + sep->is_ip4 = local_table_handle & 0xff; + local_table_handle >>= 8; + sep->transport_proto = local_table_handle & 0xff; + sep->port = local_table_handle >> 8; + return 0; +} + +u8 * +format_ip4_session_lookup_kvp (u8 * s, va_list * args) +{ + clib_bihash_kv_16_8_t *kvp = va_arg (*args, clib_bihash_kv_16_8_t *); + u32 is_local = va_arg (*args, u32); + u8 *app_name, *str = 0; + stream_session_t *session; + v4_connection_key_t *key = (v4_connection_key_t *) kvp->key; + + char *proto = key->proto == TRANSPORT_PROTO_TCP ? "T" : "U"; + if (!is_local) + { + session = session_get_from_handle (kvp->value); + app_name = application_name_from_index (session->app_index); + str = format (0, "[%s] %U:%d->%U:%d", proto, format_ip4_address, + &key->src, clib_net_to_host_u16 (key->src_port), + format_ip4_address, &key->dst, + clib_net_to_host_u16 (key->dst_port)); + s = format (s, "%-40v%-30v", str, app_name); + } + else + { + app_name = application_name_from_index (kvp->value); + str = format (0, "[%s] %U:%d", proto, format_ip4_address, + &key->src, clib_net_to_host_u16 (key->src_port)); + s = format (s, "%-30v%-30v", str, app_name); + } + vec_free (app_name); + return s; +} + +typedef struct _ip4_session_table_show_ctx_t +{ + vlib_main_t *vm; + u8 is_local; +} ip4_session_table_show_ctx_t; + +static int +ip4_session_table_show (clib_bihash_kv_16_8_t * kvp, void *arg) +{ + ip4_session_table_show_ctx_t *ctx = arg; + vlib_cli_output (ctx->vm, "%U", format_ip4_session_lookup_kvp, kvp, + ctx->is_local); + return 1; +} + +void +session_lookup_show_table_entries (vlib_main_t * vm, session_table_t * table, + u8 type, u8 is_local) +{ + ip4_session_table_show_ctx_t ctx = { + .vm = vm, + .is_local = is_local, + }; + if (!is_local) + vlib_cli_output (vm, "%-40s%-30s", "Session", "Application"); + else + vlib_cli_output (vm, "%-30s%-30s", "Listener", "Application"); + switch (type) + { + /* main table v4 */ + case 0: + ip4_session_table_walk (&table->v4_session_hash, ip4_session_table_show, + &ctx); + break; + default: + clib_warning ("not supported"); + } +} void session_lookup_init (void) { - session_lookup_t *sl = &session_lookup; - -#define _(af,table,parm,value) \ - u32 configured_##af##_##table##_table_##parm = value; - foreach_hash_table_parameter; -#undef _ - -#define _(af,table,parm,value) \ - if (session_manager_main.configured_##af##_##table##_table_##parm) \ - configured_##af##_##table##_table_##parm = \ - session_manager_main.configured_##af##_##table##_table_##parm; - foreach_hash_table_parameter; -#undef _ - - clib_bihash_init_16_8 (&sl->v4_session_hash, "v4 session table", - configured_v4_session_table_buckets, - configured_v4_session_table_memory); - clib_bihash_init_48_8 (&sl->v6_session_hash, "v6 session table", - configured_v6_session_table_buckets, - configured_v6_session_table_memory); - clib_bihash_init_16_8 (&sl->v4_half_open_hash, "v4 half-open table", - configured_v4_halfopen_table_buckets, - configured_v4_halfopen_table_memory); - clib_bihash_init_48_8 (&sl->v6_half_open_hash, "v6 half-open table", - configured_v6_halfopen_table_buckets, - configured_v6_halfopen_table_memory); + /* + * Allocate default table and map it to fib_index 0 + */ + session_table_t *st = session_table_alloc (); + vec_validate (fib_index_to_table_index[FIB_PROTOCOL_IP4], 0); + fib_index_to_table_index[FIB_PROTOCOL_IP4][0] = session_table_index (st); + session_table_init (st); + st = session_table_alloc (); + vec_validate (fib_index_to_table_index[FIB_PROTOCOL_IP6], 0); + fib_index_to_table_index[FIB_PROTOCOL_IP6][0] = session_table_index (st); + session_table_init (st); } /* diff --git a/src/vnet/session/session_lookup.h b/src/vnet/session/session_lookup.h index cf1dc01356e..20cbaf2acd6 100644 --- a/src/vnet/session/session_lookup.h +++ b/src/vnet/session/session_lookup.h @@ -16,77 +16,73 @@ #ifndef SRC_VNET_SESSION_SESSION_LOOKUP_H_ #define SRC_VNET_SESSION_SESSION_LOOKUP_H_ +#include <vnet/session/session_table.h> #include <vnet/session/stream_session.h> #include <vnet/session/transport.h> -typedef struct _session_lookup -{ - /** Lookup tables for established sessions and listeners */ - clib_bihash_16_8_t v4_session_hash; - clib_bihash_48_8_t v6_session_hash; - - /** Lookup tables for half-open sessions */ - clib_bihash_16_8_t v4_half_open_hash; - clib_bihash_48_8_t v6_half_open_hash; -} session_lookup_t; - -stream_session_t *stream_session_lookup_listener4 (ip4_address_t * lcl, - u16 lcl_port, u8 proto); -stream_session_t *stream_session_lookup4 (ip4_address_t * lcl, - ip4_address_t * rmt, u16 lcl_port, - u16 rmt_port, u8 proto); -stream_session_t *stream_session_lookup_listener6 (ip6_address_t * lcl, - u16 lcl_port, u8 proto); -stream_session_t *stream_session_lookup6 (ip6_address_t * lcl, - ip6_address_t * rmt, u16 lcl_port, - u16 rmt_port, u8 proto); -transport_connection_t *stream_session_lookup_transport_wt4 (ip4_address_t * - lcl, - ip4_address_t * - rmt, - u16 lcl_port, - u16 rmt_port, - u8 proto, - u32 - thread_index); -transport_connection_t *stream_session_lookup_transport4 (ip4_address_t * lcl, - ip4_address_t * rmt, - u16 lcl_port, - u16 rmt_port, - u8 proto); -transport_connection_t *stream_session_lookup_transport_wt6 (ip6_address_t * - lcl, - ip6_address_t * - rmt, - u16 lcl_port, - u16 rmt_port, +stream_session_t *session_lookup4 (u32 fib_index, ip4_address_t * lcl, + ip4_address_t * rmt, u16 lcl_port, + u16 rmt_port, u8 proto); +stream_session_t *session_lookup6 (u32 fib_index, ip6_address_t * lcl, + ip6_address_t * rmt, u16 lcl_port, + u16 rmt_port, u8 proto); +transport_connection_t *session_lookup_connection_wt4 (u32 fib_index, + ip4_address_t * lcl, + ip4_address_t * rmt, + u16 lcl_port, + u16 rmt_port, u8 proto, + u32 thread_index); +transport_connection_t *session_lookup_connection4 (u32 fib_index, + ip4_address_t * lcl, + ip4_address_t * rmt, + u16 lcl_port, + u16 rmt_port, u8 proto); +transport_connection_t *session_lookup_connection_wt6 (u32 fib_index, + ip6_address_t * lcl, + ip6_address_t * rmt, + u16 lcl_port, + u16 rmt_port, u8 proto, + u32 thread_index); +transport_connection_t *session_lookup_connection6 (u32 fib_index, + ip6_address_t * lcl, + ip6_address_t * rmt, + u16 lcl_port, + u16 rmt_port, u8 proto); +stream_session_t *session_lookup_listener4 (u32 fib_index, + ip4_address_t * lcl, u16 lcl_port, + u8 proto); +stream_session_t *session_lookup_listener6 (u32 fib_index, + ip6_address_t * lcl, u16 lcl_port, + u8 proto); +stream_session_t *session_lookup_listener (u32 table_index, + session_endpoint_t * sep); +int session_lookup_add_connection (transport_connection_t * tc, u64 value); +int session_lookup_del_connection (transport_connection_t * tc); +u32 session_lookup_session_endpoint (u32 table_index, + session_endpoint_t * sep); +u32 session_lookup_local_session_endpoint (u32 table_index, + session_endpoint_t * sep); +int session_lookup_add_session_endpoint (u32 table_index, + session_endpoint_t * sep, u64 value); +int session_lookup_del_session_endpoint (u32 table_index, + session_endpoint_t * sep); +int session_lookup_del_session (stream_session_t * s); +int session_lookup_del_half_open (transport_connection_t * tc); +int session_lookup_add_half_open (transport_connection_t * tc, u64 value); +u64 session_lookup_half_open_handle (transport_connection_t * tc); +transport_connection_t *session_lookup_half_open_connection (u64 handle, u8 proto, - u32 - thread_index); -transport_connection_t *stream_session_lookup_transport6 (ip6_address_t * lcl, - ip6_address_t * rmt, - u16 lcl_port, - u16 rmt_port, - u8 proto); + u8 is_ip4); +u32 session_lookup_get_index_for_fib (u32 fib_proto, u32 fib_index); -stream_session_t *stream_session_lookup_listener (ip46_address_t * lcl, - u16 lcl_port, u8 proto); -u64 stream_session_half_open_lookup_handle (ip46_address_t * lcl, - ip46_address_t * rmt, - u16 lcl_port, - u16 rmt_port, u8 proto); -transport_connection_t *stream_session_half_open_lookup (ip46_address_t * lcl, - ip46_address_t * rmt, - u16 lcl_port, - u16 rmt_port, - u8 proto); -void stream_session_table_add_for_tc (transport_connection_t * tc, u64 value); -int stream_session_table_del_for_tc (transport_connection_t * tc); -int stream_session_table_del (stream_session_t * s); -void stream_session_half_open_table_del (transport_connection_t * tc); -void stream_session_half_open_table_add (transport_connection_t * tc, - u64 value); +u64 session_lookup_local_listener_make_handle (session_endpoint_t * sep); +u8 session_lookup_local_is_handle (u64 handle); +int session_lookup_local_listener_parse_handle (u64 handle, + session_endpoint_t * sep); +void session_lookup_show_table_entries (vlib_main_t * vm, + session_table_t * table, u8 type, + u8 is_local); void session_lookup_init (void); #endif /* SRC_VNET_SESSION_SESSION_LOOKUP_H_ */ diff --git a/src/vnet/session/session_node.c b/src/vnet/session/session_node.c index d015584990e..d2291fa38de 100644 --- a/src/vnet/session/session_node.c +++ b/src/vnet/session/session_node.c @@ -434,7 +434,7 @@ dump_thread_0_event_queue (void) break; case FIFO_EVENT_DISCONNECT: - s0 = stream_session_get_from_handle (e->session_handle); + s0 = session_get_from_handle (e->session_handle); fformat (stdout, "[%04d] disconnect session %d\n", i, s0->session_index); break; @@ -477,7 +477,7 @@ session_node_cmp_event (session_fifo_event_t * e, svm_fifo_t * f) case FIFO_EVENT_DISCONNECT: break; case FIFO_EVENT_RPC: - s = stream_session_get_from_handle (e->session_handle); + s = session_get_from_handle (e->session_handle); if (!s) { clib_warning ("session has event but doesn't exist!"); @@ -644,7 +644,7 @@ skip_dequeue: } break; case FIFO_EVENT_DISCONNECT: - s0 = stream_session_get_from_handle (e0->session_handle); + s0 = session_get_from_handle (e0->session_handle); stream_session_disconnect (s0); break; case FIFO_EVENT_BUILTIN_RX: diff --git a/src/vnet/session/session_table.c b/src/vnet/session/session_table.c new file mode 100644 index 00000000000..04c0c816ab0 --- /dev/null +++ b/src/vnet/session/session_table.c @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <vnet/session/session_table.h> +#include <vnet/session/session.h> + +/** + * Pool of session tables + */ +static session_table_t *lookup_tables; + +session_table_t * +session_table_alloc (void) +{ + session_table_t *slt; + pool_get_aligned (lookup_tables, slt, CLIB_CACHE_LINE_BYTES); + memset (slt, 0, sizeof (*slt)); + return slt; +} + +u32 +session_table_index (session_table_t * slt) +{ + return (slt - lookup_tables); +} + +session_table_t * +session_table_get (u32 table_index) +{ + if (vec_len (lookup_tables) <= table_index) + return 0; + return vec_elt_at_index (lookup_tables, table_index); +} + +#define foreach_hash_table_parameter \ + _(v4,session,buckets,20000) \ + _(v4,session,memory,(64<<20)) \ + _(v6,session,buckets,20000) \ + _(v6,session,memory,(64<<20)) \ + _(v4,halfopen,buckets,20000) \ + _(v4,halfopen,memory,(64<<20)) \ + _(v6,halfopen,buckets,20000) \ + _(v6,halfopen,memory,(64<<20)) + +/** + * Initialize session table hash tables + * + * If vpp configured with set of table parameters it uses them, + * otherwise it uses defaults above. + */ +void +session_table_init (session_table_t * slt) +{ +#define _(af,table,parm,value) \ + u32 configured_##af##_##table##_table_##parm = value; + foreach_hash_table_parameter; +#undef _ + +#define _(af,table,parm,value) \ + if (session_manager_main.configured_##af##_##table##_table_##parm) \ + configured_##af##_##table##_table_##parm = \ + session_manager_main.configured_##af##_##table##_table_##parm; + foreach_hash_table_parameter; +#undef _ + + clib_bihash_init_16_8 (&slt->v4_session_hash, "v4 session table", + configured_v4_session_table_buckets, + configured_v4_session_table_memory); + clib_bihash_init_48_8 (&slt->v6_session_hash, "v6 session table", + configured_v6_session_table_buckets, + configured_v6_session_table_memory); + clib_bihash_init_16_8 (&slt->v4_half_open_hash, "v4 half-open table", + configured_v4_halfopen_table_buckets, + configured_v4_halfopen_table_memory); + clib_bihash_init_48_8 (&slt->v6_half_open_hash, "v6 half-open table", + configured_v6_halfopen_table_buckets, + configured_v6_halfopen_table_memory); +} + +typedef struct _ip4_session_table_walk_ctx_t +{ + ip4_session_table_walk_fn_t fn; + void *ctx; +} ip4_session_table_walk_ctx_t; + +void +ip4_session_table_walk_cb (clib_bihash_kv_16_8_t * kvp, void *arg) +{ + ip4_session_table_walk_ctx_t *ctx = arg; + ctx->fn (kvp, ctx->ctx); +} + +void +ip4_session_table_walk (clib_bihash_16_8_t * hash, + ip4_session_table_walk_fn_t fn, void *arg) +{ + ip4_session_table_walk_ctx_t ctx = { + .fn = fn, + .ctx = arg, + }; + clib_bihash_foreach_key_value_pair_16_8 (hash, ip4_session_table_walk_cb, + &ctx); +} + +/* *INDENT-ON* */ +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/session/session_table.h b/src/vnet/session/session_table.h new file mode 100644 index 00000000000..ce0b4a2ff25 --- /dev/null +++ b/src/vnet/session/session_table.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SRC_VNET_SESSION_SESSION_TABLE_H_ +#define SRC_VNET_SESSION_SESSION_TABLE_H_ + +#include <vppinfra/bihash_16_8.h> +#include <vppinfra/bihash_48_8.h> + +typedef struct _session_lookup_table +{ + /** + * Lookup tables for established sessions and listeners + */ + clib_bihash_16_8_t v4_session_hash; + clib_bihash_48_8_t v6_session_hash; + + /** + * Lookup tables for half-open sessions + */ + clib_bihash_16_8_t v4_half_open_hash; + clib_bihash_48_8_t v6_half_open_hash; +} session_table_t; + +#define SESSION_TABLE_INVALID_INDEX ((u32)~0) +#define SESSION_LOCAL_TABLE_PREFIX ((u32)~0) +#define SESSION_INVALID_INDEX ((u32)~0) + +typedef int (*ip4_session_table_walk_fn_t) (clib_bihash_kv_16_8_t * kvp, + void *ctx); + +void ip4_session_table_walk_cb (clib_bihash_kv_16_8_t * kvp, void *arg); +void ip4_session_table_walk (clib_bihash_16_8_t * hash, + ip4_session_table_walk_fn_t fn, void *arg); + +session_table_t *session_table_alloc (void); +session_table_t *session_table_get (u32 table_index); +u32 session_table_index (session_table_t * slt); +void session_table_init (session_table_t * slt); + +#endif /* SRC_VNET_SESSION_SESSION_TABLE_H_ */ +/* *INDENT-ON* */ +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/session/session_test.c b/src/vnet/session/session_test.c new file mode 100644 index 00000000000..b46b33d1396 --- /dev/null +++ b/src/vnet/session/session_test.c @@ -0,0 +1,473 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <vnet/session/application_namespace.h> +#include <vnet/session/application_interface.h> +#include <vnet/session/application.h> +#include <vnet/session/session.h> + +#define SESSION_TEST_I(_cond, _comment, _args...) \ +({ \ + int _evald = (_cond); \ + if (!(_evald)) { \ + fformat(stderr, "FAIL:%d: " _comment "\n", \ + __LINE__, ##_args); \ + } else { \ + fformat(stderr, "PASS:%d: " _comment "\n", \ + __LINE__, ##_args); \ + } \ + _evald; \ +}) + +#define SESSION_TEST(_cond, _comment, _args...) \ +{ \ + if (!SESSION_TEST_I(_cond, _comment, ##_args)) { \ + return 1; \ + } \ +} + +void +dummy_session_reset_callback (stream_session_t * s) +{ + clib_warning ("called..."); +} + +int +dummy_session_connected_callback (u32 app_index, u32 api_context, + stream_session_t * s, u8 is_fail) +{ + clib_warning ("called..."); + return -1; +} + +int +dummy_add_segment_callback (u32 client_index, const u8 * seg_name, + u32 seg_size) +{ + clib_warning ("called..."); + return -1; +} + +int +dummy_redirect_connect_callback (u32 client_index, void *mp) +{ + return VNET_API_ERROR_SESSION_REDIRECT; +} + +void +dummy_session_disconnect_callback (stream_session_t * s) +{ + clib_warning ("called..."); +} + +int +dummy_session_accept_callback (stream_session_t * s) +{ + clib_warning ("called..."); + return -1; +} + +int +dummy_server_rx_callback (stream_session_t * s) +{ + clib_warning ("called..."); + return -1; +} + +/* *INDENT-OFF* */ +static session_cb_vft_t dummy_session_cbs = { + .session_reset_callback = dummy_session_reset_callback, + .session_connected_callback = dummy_session_connected_callback, + .session_accept_callback = dummy_session_accept_callback, + .session_disconnect_callback = dummy_session_disconnect_callback, + .builtin_server_rx_callback = dummy_server_rx_callback, + .redirect_connect_callback = dummy_redirect_connect_callback, +}; +/* *INDENT-ON* */ + +static int +session_test_namespace (vlib_main_t * vm, unformat_input_t * input) +{ + u64 options[SESSION_OPTIONS_N_OPTIONS], dummy_secret = 1234; + u32 server_index, server_st_index, server_local_st_index; + u32 dummy_port = 1234, local_listener, client_index; + u32 dummy_api_context = 4321, dummy_client_api_index = 1234; + u32 dummy_server_api_index = ~0, sw_if_index = 0; + session_endpoint_t server_sep = SESSION_ENDPOINT_NULL; + session_endpoint_t client_sep = SESSION_ENDPOINT_NULL; + session_endpoint_t intf_sep = SESSION_ENDPOINT_NULL; + clib_error_t *error = 0; + u8 *ns_id = format (0, "appns1"), intf_mac[6]; + app_namespace_t *app_ns; + u8 segment_name[128]; + application_t *server; + stream_session_t *s; + int code; + + server_sep.is_ip4 = 1; + server_sep.port = dummy_port; + client_sep.is_ip4 = 1; + client_sep.port = dummy_port; + memset (options, 0, sizeof (options)); + memset (intf_mac, 0, sizeof (intf_mac)); + + options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_BUILTIN_APP; + options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_ACCEPT_REDIRECT; + vnet_app_attach_args_t attach_args = { + .api_client_index = ~0, + .options = options, + .namespace_id = 0, + .session_cb_vft = &dummy_session_cbs, + .segment_name = segment_name, + }; + + vnet_bind_args_t bind_args = { + .sep = server_sep, + .app_index = 0, + }; + + vnet_connect_args_t connect_args = { + .sep = client_sep, + .app_index = 0, + .api_context = 0, + }; + + vnet_unbind_args_t unbind_args = { + .handle = bind_args.handle, + .app_index = 0, + }; + + vnet_app_detach_args_t detach_args = { + .app_index = 0, + }; + + ip4_address_t intf_addr = { + .as_u32 = clib_host_to_net_u32 (0x06000105), + }; + + intf_sep.ip.ip4 = intf_addr; + intf_sep.is_ip4 = 1; + intf_sep.port = dummy_port; + + /* + * Insert namespace and lookup + */ + + vnet_app_namespace_add_del_args_t ns_args = { + .ns_id = ns_id, + .secret = dummy_secret, + .sw_if_index = APP_NAMESPACE_INVALID_INDEX, + .is_add = 1 + }; + error = vnet_app_namespace_add_del (&ns_args); + SESSION_TEST ((error == 0), "app ns insertion should succeed: %d", + clib_error_get_code (error)); + + app_ns = app_namespace_get_from_id (ns_id); + SESSION_TEST ((app_ns != 0), "should find ns %v status", ns_id); + SESSION_TEST ((app_ns->ns_secret == dummy_secret), "secret should be %d", + dummy_secret); + SESSION_TEST ((app_ns->sw_if_index == APP_NAMESPACE_INVALID_INDEX), + "sw_if_index should be invalid"); + + /* + * Try application attach with wrong secret + */ + + options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; + options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; + options[APP_OPTIONS_NAMESPACE_SECRET] = dummy_secret - 1; + attach_args.namespace_id = ns_id; + attach_args.api_client_index = dummy_server_api_index; + + error = vnet_application_attach (&attach_args); + SESSION_TEST ((error != 0), "app attachment should fail"); + code = clib_error_get_code (error); + SESSION_TEST ((code == VNET_API_ERROR_APP_WRONG_NS_SECRET), + "code should be wrong ns secret: %d", code); + + /* + * Attach server with global default scope + */ + options[APP_OPTIONS_FLAGS] &= ~APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; + options[APP_OPTIONS_FLAGS] &= ~APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; + options[APP_OPTIONS_NAMESPACE_SECRET] = 0; + attach_args.namespace_id = 0; + attach_args.api_client_index = dummy_server_api_index; + error = vnet_application_attach (&attach_args); + SESSION_TEST ((error == 0), "server attachment should work"); + server_index = attach_args.app_index; + server = application_get (server_index); + SESSION_TEST ((server->ns_index == 0), + "server should be in the default ns"); + + bind_args.app_index = server_index; + error = vnet_bind (&bind_args); + SESSION_TEST ((error == 0), "server bind should work"); + + server_st_index = application_session_table (server, FIB_PROTOCOL_IP4); + s = session_lookup_listener (server_st_index, &server_sep); + SESSION_TEST ((s != 0), "listener should exist in global table"); + SESSION_TEST ((s->app_index == server_index), "app_index should be that of " + "the server"); + server_local_st_index = application_local_session_table (server); + SESSION_TEST ((server_local_st_index == APP_INVALID_INDEX), + "server shouldn't have access to local table"); + + unbind_args.app_index = server_index; + error = vnet_unbind (&unbind_args); + SESSION_TEST ((error == 0), "unbind should work"); + + s = session_lookup_listener (server_st_index, &server_sep); + SESSION_TEST ((s == 0), "listener should not exist in global table"); + + detach_args.app_index = server_index; + vnet_application_detach (&detach_args); + + /* + * Attach server with local and global scope + */ + options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; + options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; + options[APP_OPTIONS_NAMESPACE_SECRET] = dummy_secret; + attach_args.namespace_id = ns_id; + attach_args.api_client_index = dummy_server_api_index; + error = vnet_application_attach (&attach_args); + SESSION_TEST ((error == 0), "server attachment should work"); + server_index = attach_args.app_index; + server = application_get (server_index); + SESSION_TEST ((server->ns_index == app_namespace_index (app_ns)), + "server should be in the right ns"); + + bind_args.app_index = server_index; + error = vnet_bind (&bind_args); + SESSION_TEST ((error == 0), "bind should work"); + server_st_index = application_session_table (server, FIB_PROTOCOL_IP4); + s = session_lookup_listener (server_st_index, &server_sep); + SESSION_TEST ((s != 0), "listener should exist in global table"); + SESSION_TEST ((s->app_index == server_index), "app_index should be that of " + "the server"); + server_local_st_index = application_local_session_table (server); + local_listener = session_lookup_session_endpoint (server_local_st_index, + &server_sep); + SESSION_TEST ((local_listener != SESSION_INVALID_INDEX), + "listener should exist in local table"); + + /* + * Try client connect with 1) local scope 2) global scope + */ + options[APP_OPTIONS_FLAGS] &= ~APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; + attach_args.api_client_index = dummy_client_api_index; + error = vnet_application_attach (&attach_args); + SESSION_TEST ((error == 0), "client attachment should work"); + client_index = attach_args.app_index; + connect_args.api_context = dummy_api_context; + connect_args.app_index = client_index; + error = vnet_connect (&connect_args); + SESSION_TEST ((error != 0), "client connect should return error code"); + code = clib_error_get_code (error); + SESSION_TEST ((code == VNET_API_ERROR_INVALID_VALUE), + "error code should be invalid value (zero ip)"); + connect_args.sep.ip.ip4.as_u8[0] = 127; + error = vnet_connect (&connect_args); + SESSION_TEST ((error != 0), "client connect should return error code"); + code = clib_error_get_code (error); + SESSION_TEST ((code == VNET_API_ERROR_SESSION_REDIRECT), + "error code should be redirect"); + detach_args.app_index = client_index; + vnet_application_detach (&detach_args); + + options[APP_OPTIONS_FLAGS] &= ~APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; + options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; + attach_args.api_client_index = dummy_client_api_index; + error = vnet_application_attach (&attach_args); + SESSION_TEST ((error == 0), "client attachment should work"); + error = vnet_connect (&connect_args); + SESSION_TEST ((error != 0), "client connect should return error code"); + code = clib_error_get_code (error); + SESSION_TEST ((code == VNET_API_ERROR_SESSION_CONNECT), + "error code should be connect (nothing in local scope)"); + detach_args.app_index = client_index; + vnet_application_detach (&detach_args); + + /* + * Unbind and detach server and then re-attach with local scope only + */ + unbind_args.handle = bind_args.handle; + unbind_args.app_index = server_index; + error = vnet_unbind (&unbind_args); + SESSION_TEST ((error == 0), "unbind should work"); + + s = session_lookup_listener (server_st_index, &server_sep); + SESSION_TEST ((s == 0), "listener should not exist in global table"); + local_listener = session_lookup_session_endpoint (server_local_st_index, + &server_sep); + SESSION_TEST ((s == 0), "listener should not exist in local table"); + + detach_args.app_index = server_index; + vnet_application_detach (&detach_args); + + options[APP_OPTIONS_FLAGS] &= ~APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; + options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; + attach_args.api_client_index = dummy_server_api_index; + error = vnet_application_attach (&attach_args); + SESSION_TEST ((error == 0), "app attachment should work"); + server_index = attach_args.app_index; + server = application_get (server_index); + SESSION_TEST ((server->ns_index == app_namespace_index (app_ns)), + "app should be in the right ns"); + + bind_args.app_index = server_index; + error = vnet_bind (&bind_args); + SESSION_TEST ((error == 0), "bind should work"); + + server_st_index = application_session_table (server, FIB_PROTOCOL_IP4); + s = session_lookup_listener (server_st_index, &server_sep); + SESSION_TEST ((s == 0), "listener should not exist in global table"); + server_local_st_index = application_local_session_table (server); + local_listener = session_lookup_session_endpoint (server_local_st_index, + &server_sep); + SESSION_TEST ((local_listener != SESSION_INVALID_INDEX), + "listener should exist in local table"); + + unbind_args.handle = bind_args.handle; + error = vnet_unbind (&unbind_args); + SESSION_TEST ((error == 0), "unbind should work"); + + local_listener = session_lookup_session_endpoint (server_local_st_index, + &server_sep); + SESSION_TEST ((local_listener == SESSION_INVALID_INDEX), + "listener should not exist in local table"); + + /* + * Client attach + connect in default ns with local scope + */ + options[APP_OPTIONS_FLAGS] &= ~APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; + options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; + attach_args.namespace_id = 0; + attach_args.api_client_index = dummy_client_api_index; + vnet_application_attach (&attach_args); + error = vnet_connect (&connect_args); + SESSION_TEST ((error != 0), "client connect should return error code"); + code = clib_error_get_code (error); + SESSION_TEST ((code == VNET_API_ERROR_SESSION_CONNECT), + "error code should be connect (not in same ns)"); + detach_args.app_index = client_index; + vnet_application_detach (&detach_args); + + /* + * Detach server + */ + detach_args.app_index = server_index; + vnet_application_detach (&detach_args); + + /* + * Create loopback interface + */ + if (vnet_create_loopback_interface (&sw_if_index, intf_mac, 0, 0)) + { + clib_warning ("couldn't create loopback. stopping the test!"); + return 0; + } + vnet_sw_interface_set_flags (vnet_get_main (), sw_if_index, + VNET_SW_INTERFACE_FLAG_ADMIN_UP); + ip4_add_del_interface_address (vlib_get_main (), sw_if_index, &intf_addr, + 24, 0); + + /* + * Update namespace + */ + ns_args.sw_if_index = sw_if_index; + error = vnet_app_namespace_add_del (&ns_args); + SESSION_TEST ((error == 0), "app ns insertion should succeed: %d", + clib_error_get_code (error)); + + /* + * Attach server with local and global scope + */ + options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; + options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; + options[APP_OPTIONS_NAMESPACE_SECRET] = dummy_secret; + attach_args.namespace_id = ns_id; + attach_args.api_client_index = dummy_server_api_index; + error = vnet_application_attach (&attach_args); + SESSION_TEST ((error == 0), "server attachment should work"); + server_index = attach_args.app_index; + + bind_args.app_index = server_index; + error = vnet_bind (&bind_args); + server_st_index = application_session_table (server, FIB_PROTOCOL_IP4); + s = session_lookup_listener (server_st_index, &server_sep); + SESSION_TEST ((s == 0), "zero listener should not exist in global table"); + + s = session_lookup_listener (server_st_index, &intf_sep); + SESSION_TEST ((s != 0), "intf listener should exist in global table"); + SESSION_TEST ((s->app_index == server_index), "app_index should be that of " + "the server"); + server_local_st_index = application_local_session_table (server); + local_listener = session_lookup_session_endpoint (server_local_st_index, + &server_sep); + SESSION_TEST ((local_listener != SESSION_INVALID_INDEX), + "zero listener should exist in local table"); + detach_args.app_index = server_index; + vnet_application_detach (&detach_args); + + /* + * Cleanup + */ + vec_free (ns_id); + vnet_delete_loopback_interface (sw_if_index); + return 0; +} + +static clib_error_t * +session_test (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd_arg) +{ + int res = 0; + + vnet_session_enable_disable (vm, 1); + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "namespace")) + { + res = session_test_namespace (vm, input); + } + else + break; + } + + if (res) + return clib_error_return (0, "Session unit test failed"); + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (tcp_test_command, static) = +{ + .path = "test session", + .short_help = "internal session unit tests", + .function = session_test, +}; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/session/stream_session.h b/src/vnet/session/stream_session.h index 275052d3ee5..1ed6e0b9eec 100644 --- a/src/vnet/session/stream_session.h +++ b/src/vnet/session/stream_session.h @@ -18,6 +18,7 @@ #include <vnet/vnet.h> #include <svm/svm_fifo.h> +#include <vnet/session/transport.h> #define foreach_session_type \ _(IP4_TCP, ip4_tcp) \ @@ -81,6 +82,44 @@ typedef struct _stream_session_t CLIB_CACHE_LINE_ALIGN_MARK (pad); } stream_session_t; +typedef struct _session_endpoint +{ + /* + * Network specific + */ +#define _(type, name) type name; + foreach_transport_connection_fields +#undef _ + /* + * Session specific + */ + u8 transport_proto; /**< transport protocol for session */ +} session_endpoint_t; + +#define SESSION_IP46_ZERO \ +{ \ + .ip6 = { \ + { 0, 0, }, \ + }, \ +} +#define SESSION_ENDPOINT_NULL \ +{ \ + .sw_if_index = ENDPOINT_INVALID_INDEX, \ + .ip = SESSION_IP46_ZERO, \ + .fib_index = ENDPOINT_INVALID_INDEX, \ + .is_ip4 = 0, \ + .port = 0, \ + .transport_proto = 0, \ +} + +#define session_endpoint_to_transport(_sep) ((transport_endpoint_t *)_sep) + +always_inline u8 +session_endpoint_fib_proto (session_endpoint_t * sep) +{ + return sep->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6; +} + #endif /* SRC_VNET_SESSION_STREAM_SESSION_H_ */ /* diff --git a/src/vnet/session/transport.h b/src/vnet/session/transport.h index e2c479494ca..8c299c46490 100644 --- a/src/vnet/session/transport.h +++ b/src/vnet/session/transport.h @@ -18,8 +18,6 @@ #include <vnet/vnet.h> #include <vnet/ip/ip.h> -#include <vppinfra/bihash_16_8.h> -#include <vppinfra/bihash_48_8.h> #include <vnet/tcp/tcp_debug.h> /* @@ -33,7 +31,7 @@ typedef struct _transport_connection u16 rmt_port; /**< Remote port */ u8 transport_proto; /**< Protocol id */ u8 is_ip4; /**< Flag if IP4 connection */ - u32 vrf; /**< FIB table id */ + u32 fib_index; /**< Network namespace */ u32 s_index; /**< Parent session index */ u32 c_index; /**< Connection index in transport pool */ @@ -57,8 +55,7 @@ typedef struct _transport_connection #define c_lcl_port connection.lcl_port #define c_rmt_port connection.rmt_port #define c_transport_proto connection.transport_proto -#define c_vrf connection.vrf -#define c_state connection.state +#define c_fib_index connection.fib_index #define c_s_index connection.s_index #define c_c_index connection.c_index #define c_is_ip4 connection.is_ip4 @@ -75,14 +72,28 @@ typedef enum _transport_proto TRANSPORT_PROTO_UDP } transport_proto_t; +#define foreach_transport_connection_fields \ + _(u32, sw_if_index) /**< interface endpoint is associated with */ \ + _(ip46_address_t, ip) /**< ip address */ \ + _(u32, fib_index) /**< fib table endpoint is associated with */ \ + _(u8, is_ip4) /**< 1 if ip4 */ \ + _(u16, port) /**< port in net order */ \ + typedef struct _transport_endpoint { - ip46_address_t ip; /** ip address */ - u16 port; /** port in net order */ - u8 is_ip4; /** 1 if ip4 */ - u32 vrf; /** fib table the endpoint is associated with */ +#define _(type, name) type name; + foreach_transport_connection_fields +#undef _ } transport_endpoint_t; +#define ENDPOINT_INVALID_INDEX ((u32)~0) + +always_inline u8 +transport_connection_fib_proto (transport_connection_t * tc) +{ + return tc->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6; +} + #endif /* VNET_VNET_URI_TRANSPORT_H_ */ /* diff --git a/src/vnet/tcp/builtin_client.c b/src/vnet/tcp/builtin_client.c index b48422c0b30..7a0d2ea1744 100644 --- a/src/vnet/tcp/builtin_client.c +++ b/src/vnet/tcp/builtin_client.c @@ -246,8 +246,8 @@ builtin_client_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node, __sync_fetch_and_add (&tm->tx_total, sp->bytes_sent); __sync_fetch_and_add (&tm->rx_total, sp->bytes_received); - stream_session_parse_handle (sp->vpp_session_handle, - &index, &thread_index); + session_parse_handle (sp->vpp_session_handle, + &index, &thread_index); s = stream_session_get_if_valid (index, thread_index); if (s) @@ -425,14 +425,16 @@ static session_cb_vft_t builtin_clients = { }; /* *INDENT-ON* */ -static int -attach_builtin_test_clients_app (void) +static clib_error_t * +attach_builtin_test_clients_app (u8 * appns_id, u64 appns_flags, + u64 appns_secret) { tclient_main_t *tm = &tclient_main; vnet_app_attach_args_t _a, *a = &_a; u8 segment_name[128]; u32 segment_name_length, prealloc_fifos; u64 options[16]; + clib_error_t *error = 0; segment_name_length = ARRAY_LEN (segment_name); @@ -455,11 +457,16 @@ attach_builtin_test_clients_app (void) options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = prealloc_fifos; options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_BUILTIN_APP; - + if (appns_id) + { + options[APP_OPTIONS_FLAGS] |= appns_flags; + options[APP_OPTIONS_NAMESPACE_SECRET] = appns_secret; + } a->options = options; + a->namespace_id = appns_id; - if (vnet_application_attach (a)) - return -1; + if ((error = vnet_application_attach (a))) + return error; tm->app_index = a->app_index; return 0; @@ -489,11 +496,12 @@ start_tx_pthread (tclient_main_t * tm) return 0; } -void +clib_error_t * clients_connect (vlib_main_t * vm, u8 * uri, u32 n_clients) { tclient_main_t *tm = &tclient_main; vnet_connect_args_t _a, *a = &_a; + clib_error_t *error = 0; int i; for (i = 0; i < n_clients; i++) { @@ -503,7 +511,10 @@ clients_connect (vlib_main_t * vm, u8 * uri, u32 n_clients) a->api_context = i; a->app_index = tm->app_index; a->mp = 0; - vnet_connect_uri (a); + + if ((error = vnet_connect_uri (a))) + return error; + /* Crude pacing for call setups */ if ((i % 4) == 0) @@ -514,6 +525,7 @@ clients_connect (vlib_main_t * vm, u8 * uri, u32 n_clients) vlib_process_suspend (vm, 100e-6); } } + return 0; } static clib_error_t * @@ -524,13 +536,14 @@ test_tcp_clients_command_fn (vlib_main_t * vm, tclient_main_t *tm = &tclient_main; vlib_thread_main_t *thread_main = vlib_get_thread_main (); uword *event_data = 0, event_type; - u8 *default_connect_uri = (u8 *) "tcp://6.0.1.1/1234", *uri; - u64 tmp, total_bytes; + u8 *default_connect_uri = (u8 *) "tcp://6.0.1.1/1234", *uri, *appns_id; + u64 tmp, total_bytes, appns_flags = 0, appns_secret = 0; f64 test_timeout = 20.0, syn_timeout = 20.0, delta; f64 time_before_connects; u32 n_clients = 1; int preallocate_sessions = 0; char *transfer_type; + clib_error_t *error = 0; int i; tm->bytes_to_send = 8192; @@ -582,6 +595,17 @@ test_tcp_clients_command_fn (vlib_main_t * vm, else if (unformat (input, "client-batch %d", &tm->connections_per_batch)) ; + else if (unformat (input, "appns %_%v%_", &appns_id)) + ; + else if (unformat (input, "all-scope")) + appns_flags |= (APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE + | APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE); + else if (unformat (input, "local-scope")) + appns_flags = APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; + else if (unformat (input, "global-scope")) + appns_flags = APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; + else if (unformat (input, "secret %lu", &appns_secret)) + ; else return clib_error_return (0, "unknown input `%U'", format_unformat_error, input); @@ -616,10 +640,14 @@ test_tcp_clients_command_fn (vlib_main_t * vm, if (tm->test_client_attached == 0) { - if (attach_builtin_test_clients_app ()) + if ((error = attach_builtin_test_clients_app (appns_id, appns_flags, + appns_secret))) { - return clib_error_return (0, "app attach failed"); + vec_free (appns_id); + clib_error_report (error); + return error; } + vec_free (appns_id); } tm->test_client_attached = 1; @@ -639,7 +667,8 @@ test_tcp_clients_command_fn (vlib_main_t * vm, /* Fire off connect requests */ time_before_connects = vlib_time_now (vm); - clients_connect (vm, uri, n_clients); + if ((error = clients_connect (vm, uri, n_clients))) + return error; /* Park until the sessions come up, or ten seconds elapse... */ vlib_process_wait_for_event_or_clock (vm, syn_timeout); diff --git a/src/vnet/tcp/builtin_http_server.c b/src/vnet/tcp/builtin_http_server.c index 9ba19ce92f7..f808400d63d 100644 --- a/src/vnet/tcp/builtin_http_server.c +++ b/src/vnet/tcp/builtin_http_server.c @@ -129,7 +129,7 @@ send_data (builtin_http_server_args * args, u8 * data) f64 last_sent_timer = vlib_time_now (vm); stream_session_t *s; - s = stream_session_get_from_handle (args->session_handle); + s = session_get_from_handle (args->session_handle); ASSERT (s); bytes_to_send = vec_len (data); offset = 0; diff --git a/src/vnet/tcp/builtin_proxy.c b/src/vnet/tcp/builtin_proxy.c index 91377e76726..a51a812ca16 100644 --- a/src/vnet/tcp/builtin_proxy.c +++ b/src/vnet/tcp/builtin_proxy.c @@ -50,8 +50,7 @@ delete_proxy_session (stream_session_t * s, int is_active_open) { ps = pool_elt_at_index (bpm->sessions, p[0]); if (ps->vpp_server_handle != ~0) - server_session = stream_session_get_from_handle - (ps->vpp_server_handle); + server_session = session_get_from_handle (ps->vpp_server_handle); else server_session = 0; } @@ -71,7 +70,7 @@ delete_proxy_session (stream_session_t * s, int is_active_open) { ps = pool_elt_at_index (bpm->sessions, p[0]); if (ps->vpp_server_handle != ~0) - active_open_session = stream_session_get_from_handle + active_open_session = session_get_from_handle (ps->vpp_server_handle); else active_open_session = 0; diff --git a/src/vnet/tcp/builtin_server.c b/src/vnet/tcp/builtin_server.c index 93314529973..b4a52c67fcd 100644 --- a/src/vnet/tcp/builtin_server.c +++ b/src/vnet/tcp/builtin_server.c @@ -272,7 +272,7 @@ create_api_loopback (vlib_main_t * vm) } static int -server_attach () +server_attach (u8 * appns_id, u64 appns_flags, u64 appns_secret) { builtin_server_main_t *bsm = &builtin_server_main; u8 segment_name[128]; @@ -300,7 +300,12 @@ server_attach () bsm->prealloc_fifos ? bsm->prealloc_fifos : 1; a->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_BUILTIN_APP; - + if (appns_id) + { + a->namespace_id = appns_id; + a->options[APP_OPTIONS_FLAGS] |= appns_flags; + a->options[APP_OPTIONS_NAMESPACE_SECRET] = appns_secret; + } a->segment_name = segment_name; a->segment_name_length = ARRAY_LEN (segment_name); @@ -325,7 +330,8 @@ server_listen () } static int -server_create (vlib_main_t * vm) +server_create (vlib_main_t * vm, u8 * appns_id, u64 appns_flags, + u64 appns_secret) { builtin_server_main_t *bsm = &builtin_server_main; vlib_thread_main_t *vtm = vlib_get_thread_main (); @@ -349,7 +355,7 @@ server_create (vlib_main_t * vm) for (i = 0; i < num_threads; i++) vec_validate (bsm->rx_buf[i], bsm->rcv_buffer_size); - if (server_attach ()) + if (server_attach (appns_id, appns_flags, appns_secret)) { clib_warning ("failed to attach server"); return -1; @@ -367,9 +373,9 @@ server_create_command_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { builtin_server_main_t *bsm = &builtin_server_main; - u8 server_uri_set = 0; + u8 server_uri_set = 0, *appns_id = 0; + u64 tmp, appns_flags = 0, appns_secret = 0; int rv; - u64 tmp; bsm->no_echo = 0; bsm->fifo_size = 64 << 10; @@ -402,6 +408,17 @@ server_create_command_fn (vlib_main_t * vm, unformat_input_t * input, } else if (unformat (input, "uri %s", &bsm->server_uri)) server_uri_set = 1; + else if (unformat (input, "appns %_%v%_", &appns_id)) + ; + else if (unformat (input, "all-scope")) + appns_flags |= (APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE + | APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE); + else if (unformat (input, "local-scope")) + appns_flags |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; + else if (unformat (input, "global-scope")) + appns_flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; + else if (unformat (input, "secret %lu", &appns_secret)) + ; else return clib_error_return (0, "unknown input `%U'", format_unformat_error, input); @@ -412,7 +429,8 @@ server_create_command_fn (vlib_main_t * vm, unformat_input_t * input, if (!server_uri_set) bsm->server_uri = (char *) format (0, "tcp://0.0.0.0/1234%c", 0); - rv = server_create (vm); + rv = server_create (vm, appns_id, appns_flags, appns_secret); + vec_free (appns_id); switch (rv) { case 0: diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c index 2a705d01b4c..52e945a262b 100644 --- a/src/vnet/tcp/tcp.c +++ b/src/vnet/tcp/tcp.c @@ -28,11 +28,45 @@ tcp_main_t tcp_main; +void * +ip_interface_get_first_ip (u32 sw_if_index, u8 is_ip4) +{ + ip_lookup_main_t *lm4 = &ip4_main.lookup_main; + ip_lookup_main_t *lm6 = &ip6_main.lookup_main; + ip_interface_address_t *ia = 0; + + if (is_ip4) + { + /* *INDENT-OFF* */ + foreach_ip_interface_address (lm4, ia, sw_if_index, 1 /* unnumbered */ , + ({ + return ip_interface_address_get_address (lm4, ia); + })); + /* *INDENT-ON* */ + } + else + { + /* *INDENT-OFF* */ + foreach_ip_interface_address (lm6, ia, sw_if_index, 1 /* unnumbered */ , + ({ + ip6_address_t *rv; + rv = ip_interface_address_get_address (lm6, ia); + /* Trying to use a link-local ip6 src address is a fool's errand */ + if (!ip6_address_is_link_local_unicast (rv)) + return rv; + })); + /* *INDENT-ON* */ + } + + return 0; +} + static u32 tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl) { tcp_main_t *tm = &tcp_main; tcp_connection_t *listener; + void *iface_ip; pool_get (tm->listener_pool, listener); memset (listener, 0, sizeof (*listener)); @@ -40,19 +74,18 @@ tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl) listener->c_c_index = listener - tm->listener_pool; listener->c_lcl_port = lcl->port; - if (lcl->is_ip4) + /* If we are provided a sw_if_index, bind using one of its ips */ + if (ip_is_zero (&lcl->ip, 1) && lcl->sw_if_index != ENDPOINT_INVALID_INDEX) { - listener->c_lcl_ip4.as_u32 = lcl->ip.ip4.as_u32; - listener->c_is_ip4 = 1; - } - else - { - clib_memcpy (&listener->c_lcl_ip6, &lcl->ip.ip6, - sizeof (ip6_address_t)); - + if ((iface_ip = ip_interface_get_first_ip (lcl->sw_if_index, + lcl->is_ip4))) + ip_set (&lcl->ip, iface_ip, lcl->is_ip4); } + ip_copy (&listener->c_lcl_ip, &lcl->ip, lcl->is_ip4); + listener->c_is_ip4 = lcl->is_ip4; listener->c_transport_proto = TRANSPORT_PROTO_TCP; listener->c_s_index = session_index; + listener->c_fib_index = lcl->fib_index; listener->state = TCP_STATE_LISTEN; tcp_connection_timers_init (listener); @@ -355,39 +388,6 @@ tcp_session_cleanup (u32 conn_index, u32 thread_index) tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); } -void * -ip_interface_get_first_ip (u32 sw_if_index, u8 is_ip4) -{ - ip_lookup_main_t *lm4 = &ip4_main.lookup_main; - ip_lookup_main_t *lm6 = &ip6_main.lookup_main; - ip_interface_address_t *ia = 0; - - if (is_ip4) - { - /* *INDENT-OFF* */ - foreach_ip_interface_address (lm4, ia, sw_if_index, 1 /* unnumbered */ , - ({ - return ip_interface_address_get_address (lm4, ia); - })); - /* *INDENT-ON* */ - } - else - { - /* *INDENT-OFF* */ - foreach_ip_interface_address (lm6, ia, sw_if_index, 1 /* unnumbered */ , - ({ - ip6_address_t *rv; - rv = ip_interface_address_get_address (lm6, ia); - /* Trying to use a link-local ip6 src address is a fool's errand */ - if (!ip6_address_is_link_local_unicast (rv)) - return rv; - })); - /* *INDENT-ON* */ - } - - return 0; -} - #define PORT_MASK ((1 << 16)- 1) /** * Allocate local port and add if successful add entry to local endpoint @@ -528,7 +528,7 @@ tcp_lookup_rmt_in_fib (tcp_connection_t * tc) clib_memcpy (&prefix.fp_addr, &tc->c_rmt_ip, sizeof (prefix.fp_addr)); prefix.fp_proto = tc->c_is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6; prefix.fp_len = tc->c_is_ip4 ? 32 : 128; - fib_index = fib_table_find (prefix.fp_proto, tc->c_vrf); + fib_index = fib_table_find (prefix.fp_proto, tc->c_fib_index); return fib_table_lookup (fib_index, &prefix); } @@ -575,6 +575,7 @@ tcp_init_snd_vars (tcp_connection_t * tc) u32 time_now; /* Set random initial sequence */ + tcp_set_time_now (0); time_now = tcp_time_now (); tc->iss = random_u32 (&time_now); tc->snd_una = tc->iss; @@ -606,7 +607,7 @@ tcp_connection_open (transport_endpoint_t * rmt) tcp_connection_t *tc; fib_prefix_t prefix; fib_node_index_t fei; - u32 sw_if_index, fib_index; + u32 sw_if_index; ip46_address_t lcl_addr; int lcl_port; @@ -620,14 +621,8 @@ tcp_connection_open (transport_endpoint_t * rmt) prefix.fp_proto = rmt->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6; prefix.fp_len = rmt->is_ip4 ? 32 : 128; - fib_index = fib_table_find (prefix.fp_proto, rmt->vrf); - if (fib_index == (u32) ~ 0) - { - clib_warning ("no fib table"); - return -1; - } - - fei = fib_table_lookup (fib_index, &prefix); + ASSERT (rmt->fib_index != ENDPOINT_INVALID_INDEX); + fei = fib_table_lookup (rmt->fib_index, &prefix); /* Couldn't find route to destination. Bail out. */ if (fei == FIB_NODE_INDEX_INVALID) @@ -636,12 +631,14 @@ tcp_connection_open (transport_endpoint_t * rmt) return -1; } - sw_if_index = fib_entry_get_resolving_interface (fei); + sw_if_index = rmt->sw_if_index; + if (sw_if_index == ENDPOINT_INVALID_INDEX) + sw_if_index = fib_entry_get_resolving_interface (fei); - if (sw_if_index == (u32) ~ 0) + if (sw_if_index == ENDPOINT_INVALID_INDEX) { clib_warning ("no resolving interface for %U", format_ip46_address, - &rmt->ip, IP46_TYPE_IP4); + &rmt->ip, (rmt->is_ip4 == 0) + 1); return -1; } @@ -709,7 +706,7 @@ tcp_connection_open (transport_endpoint_t * rmt) tc->c_lcl_port = clib_host_to_net_u16 (lcl_port); tc->c_is_ip4 = rmt->is_ip4; tc->c_transport_proto = TRANSPORT_PROTO_TCP; - tc->c_vrf = rmt->vrf; + tc->c_fib_index = rmt->fib_index; /* The other connection vars will be initialized after SYN ACK */ tcp_connection_timers_init (tc); diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c index 1679f818947..3a32e62d243 100644 --- a/src/vnet/tcp/tcp_input.c +++ b/src/vnet/tcp/tcp_input.c @@ -1469,7 +1469,7 @@ tcp_session_enqueue_ooo (tcp_connection_t * tc, vlib_buffer_t * b, ooo_segment_t *newest; u32 start, end; - s0 = stream_session_get (tc->c_s_index, tc->c_thread_index); + s0 = session_get (tc->c_s_index, tc->c_thread_index); /* Get the newest segment from the fifo */ newest = svm_fifo_newest_ooo_segment (s0->server_rx_fifo); @@ -1859,7 +1859,9 @@ vlib_node_registration_t tcp6_syn_sent_node; static u8 tcp_lookup_is_valid (tcp_connection_t * tc, tcp_header_t * hdr) { - transport_connection_t *tmp; + transport_connection_t *tmp = 0; + u64 handle; + if (!tc) return 1; @@ -1869,15 +1871,17 @@ tcp_lookup_is_valid (tcp_connection_t * tc, tcp_header_t * hdr) if (!is_valid) { - if ((tmp = - stream_session_half_open_lookup (&tc->c_lcl_ip, &tc->c_rmt_ip, - tc->c_lcl_port, tc->c_rmt_port, - tc->c_transport_proto))) + handle = session_lookup_half_open_handle (&tc->connection); + tmp = session_lookup_half_open_connection (handle & 0xFFFFFFFF, + tc->c_transport_proto, + tc->c_is_ip4); + + if (tmp) { if (tmp->lcl_port == hdr->dst_port && tmp->rmt_port == hdr->src_port) { - clib_warning ("half-open is valid!"); + TCP_DBG ("half-open is valid!"); } } } @@ -1888,7 +1892,8 @@ tcp_lookup_is_valid (tcp_connection_t * tc, tcp_header_t * hdr) * Lookup transport connection */ static tcp_connection_t * -tcp_lookup_connection (vlib_buffer_t * b, u8 thread_index, u8 is_ip4) +tcp_lookup_connection (u32 fib_index, vlib_buffer_t * b, u8 thread_index, + u8 is_ip4) { tcp_header_t *tcp; transport_connection_t *tconn; @@ -1898,12 +1903,13 @@ tcp_lookup_connection (vlib_buffer_t * b, u8 thread_index, u8 is_ip4) ip4_header_t *ip4; ip4 = vlib_buffer_get_current (b); tcp = ip4_next_header (ip4); - tconn = stream_session_lookup_transport_wt4 (&ip4->dst_address, - &ip4->src_address, - tcp->dst_port, - tcp->src_port, - SESSION_TYPE_IP4_TCP, - thread_index); + tconn = session_lookup_connection_wt4 (fib_index, + &ip4->dst_address, + &ip4->src_address, + tcp->dst_port, + tcp->src_port, + TRANSPORT_PROTO_TCP, + thread_index); tc = tcp_get_connection_from_transport (tconn); ASSERT (tcp_lookup_is_valid (tc, tcp)); } @@ -1912,12 +1918,13 @@ tcp_lookup_connection (vlib_buffer_t * b, u8 thread_index, u8 is_ip4) ip6_header_t *ip6; ip6 = vlib_buffer_get_current (b); tcp = ip6_next_header (ip6); - tconn = stream_session_lookup_transport_wt6 (&ip6->dst_address, - &ip6->src_address, - tcp->dst_port, - tcp->src_port, - SESSION_TYPE_IP6_TCP, - thread_index); + tconn = session_lookup_connection_wt6 (fib_index, + &ip6->dst_address, + &ip6->src_address, + tcp->dst_port, + tcp->src_port, + TRANSPORT_PROTO_TCP, + thread_index); tc = tcp_get_connection_from_transport (tconn); ASSERT (tcp_lookup_is_valid (tc, tcp)); } @@ -1975,7 +1982,8 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node, if (PREDICT_FALSE (tc0->flags & TCP_CONN_HALF_OPEN_DONE)) { /* Make sure the connection actually exists */ - ASSERT (tcp_lookup_connection (b0, my_thread_index, is_ip4)); + ASSERT (tcp_lookup_connection (tc0->c_fib_index, b0, + my_thread_index, is_ip4)); goto drop; } @@ -2309,7 +2317,9 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, if (CLIB_DEBUG) { tcp_connection_t *tmp; - tmp = tcp_lookup_connection (b0, my_thread_index, is_ip4); + tmp = + tcp_lookup_connection (tc0->c_fib_index, b0, my_thread_index, + is_ip4); if (tmp->state != tc0->state) { clib_warning ("state changed"); @@ -2657,7 +2667,6 @@ tcp46_listen_inline (vlib_main_t * vm, vlib_node_runtime_t * node, { u32 n_left_from, next_index, *from, *to_next; u32 my_thread_index = vm->thread_index; - u8 sst = is_ip4 ? SESSION_TYPE_IP4_TCP : SESSION_TYPE_IP6_TCP; from = vlib_frame_vector_args (from_frame); n_left_from = from_frame->n_vectors; @@ -2719,7 +2728,9 @@ tcp46_listen_inline (vlib_main_t * vm, vlib_node_runtime_t * node, /* 3. check for a SYN (did that already) */ /* Make sure connection wasn't just created */ - child0 = tcp_lookup_connection (b0, my_thread_index, is_ip4); + child0 = + tcp_lookup_connection (lc0->c_fib_index, b0, my_thread_index, + is_ip4); if (PREDICT_FALSE (child0->state != TCP_STATE_LISTEN)) { error0 = TCP_ERROR_CREATE_EXISTS; @@ -2746,7 +2757,7 @@ tcp46_listen_inline (vlib_main_t * vm, vlib_node_runtime_t * node, sizeof (ip6_address_t)); } - if (stream_session_accept (&child0->connection, lc0->c_s_index, sst, + if (stream_session_accept (&child0->connection, lc0->c_s_index, 0 /* notify */ )) { clib_warning ("session accept fail"); @@ -2924,7 +2935,7 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, while (n_left_from > 0 && n_left_to_next > 0) { int n_advance_bytes0, n_data_bytes0; - u32 bi0; + u32 bi0, fib_index0; vlib_buffer_t *b0; tcp_header_t *tcp0 = 0; tcp_connection_t *tc0; @@ -2943,6 +2954,7 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, b0 = vlib_get_buffer (vm, bi0); vnet_buffer (b0)->tcp.flags = 0; + fib_index0 = vnet_buffer (b0)->ip.fib_index; /* Checksum computed by ipx_local no need to compute again */ @@ -2954,12 +2966,12 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, + tcp_header_bytes (tcp0)); n_data_bytes0 = clib_net_to_host_u16 (ip40->length) - n_advance_bytes0; - tconn = stream_session_lookup_transport_wt4 (&ip40->dst_address, - &ip40->src_address, - tcp0->dst_port, - tcp0->src_port, - SESSION_TYPE_IP4_TCP, - my_thread_index); + tconn = + session_lookup_connection_wt4 (fib_index0, &ip40->dst_address, + &ip40->src_address, + tcp0->dst_port, tcp0->src_port, + TRANSPORT_PROTO_TCP, + my_thread_index); tc0 = tcp_get_connection_from_transport (tconn); ASSERT (tcp_lookup_is_valid (tc0, tcp0)); } @@ -2971,12 +2983,12 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, n_data_bytes0 = clib_net_to_host_u16 (ip60->payload_length) - n_advance_bytes0; n_advance_bytes0 += sizeof (ip60[0]); - tconn = stream_session_lookup_transport_wt6 (&ip60->dst_address, - &ip60->src_address, - tcp0->dst_port, - tcp0->src_port, - SESSION_TYPE_IP6_TCP, - my_thread_index); + tconn = + session_lookup_connection_wt6 (fib_index0, &ip60->dst_address, + &ip60->src_address, + tcp0->dst_port, tcp0->src_port, + TRANSPORT_PROTO_TCP, + my_thread_index); tc0 = tcp_get_connection_from_transport (tconn); ASSERT (tcp_lookup_is_valid (tc0, tcp0)); } diff --git a/src/vnet/tcp/tcp_output.c b/src/vnet/tcp/tcp_output.c index e921a4a13ea..3509ad4701d 100644 --- a/src/vnet/tcp/tcp_output.c +++ b/src/vnet/tcp/tcp_output.c @@ -1741,8 +1741,7 @@ tcp_fast_retransmit (tcp_connection_t * tc) always_inline u32 tcp_session_has_ooo_data (tcp_connection_t * tc) { - stream_session_t *s = - stream_session_get (tc->c_s_index, tc->c_thread_index); + stream_session_t *s = session_get (tc->c_s_index, tc->c_thread_index); return svm_fifo_has_ooo_data (s->server_rx_fifo); } diff --git a/src/vnet/tcp/tcp_test.c b/src/vnet/tcp/tcp_test.c index 37640cc61b9..2018855840f 100644 --- a/src/vnet/tcp/tcp_test.c +++ b/src/vnet/tcp/tcp_test.c @@ -1597,11 +1597,11 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input) * Confirm that connection lookup works */ - stream_session_table_add_for_tc (tc1, tc1->s_index); - tconn = stream_session_lookup_transport_wt4 (&tc1->lcl_ip.ip4, - &tc1->rmt_ip.ip4, - tc1->lcl_port, tc1->rmt_port, - tc1->transport_proto, 0); + session_lookup_add_connection (tc1, tc1->s_index); + tconn = session_lookup_connection_wt4 (0, &tc1->lcl_ip.ip4, + &tc1->rmt_ip.ip4, + tc1->lcl_port, tc1->rmt_port, + tc1->transport_proto, 0); cmp = (memcmp (&tconn->rmt_ip, &tc1->rmt_ip, sizeof (tc1->rmt_ip)) == 0); TCP_TEST ((cmp), "rmt ip is identical %d", cmp); TCP_TEST ((tconn->lcl_port == tc1->lcl_port), @@ -1611,35 +1611,35 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input) * Non-existing connection lookup should not work */ - tconn = stream_session_lookup_transport_wt4 (&tc2->lcl_ip.ip4, - &tc2->rmt_ip.ip4, - tc2->lcl_port, tc2->rmt_port, - tc2->transport_proto, 0); + tconn = session_lookup_connection_wt4 (0, &tc2->lcl_ip.ip4, + &tc2->rmt_ip.ip4, + tc2->lcl_port, tc2->rmt_port, + tc2->transport_proto, 0); TCP_TEST ((tconn == 0), "lookup result should be null"); /* * Delete and lookup again */ - stream_session_table_del_for_tc (tc1); - tconn = stream_session_lookup_transport_wt4 (&tc1->lcl_ip.ip4, - &tc1->rmt_ip.ip4, - tc1->lcl_port, tc1->rmt_port, - tc1->transport_proto, 0); + session_lookup_del_connection (tc1); + tconn = session_lookup_connection_wt4 (0, &tc1->lcl_ip.ip4, + &tc1->rmt_ip.ip4, + tc1->lcl_port, tc1->rmt_port, + tc1->transport_proto, 0); TCP_TEST ((tconn == 0), "lookup result should be null"); - tconn = stream_session_lookup_transport_wt4 (&tc2->lcl_ip.ip4, - &tc2->rmt_ip.ip4, - tc2->lcl_port, tc2->rmt_port, - tc2->transport_proto, 0); + tconn = session_lookup_connection_wt4 (0, &tc2->lcl_ip.ip4, + &tc2->rmt_ip.ip4, + tc2->lcl_port, tc2->rmt_port, + tc2->transport_proto, 0); TCP_TEST ((tconn == 0), "lookup result should be null"); /* * Re-add and lookup tc2 */ - stream_session_table_add_for_tc (tc1, tc1->s_index); - tconn = stream_session_lookup_transport_wt4 (&tc2->lcl_ip.ip4, - &tc2->rmt_ip.ip4, - tc2->lcl_port, tc2->rmt_port, - tc2->transport_proto, 0); + session_lookup_add_connection (tc1, tc1->s_index); + tconn = session_lookup_connection_wt4 (0, &tc2->lcl_ip.ip4, + &tc2->rmt_ip.ip4, + tc2->lcl_port, tc2->rmt_port, + tc2->transport_proto, 0); TCP_TEST ((tconn == 0), "lookup result should be null"); return 0; @@ -1650,7 +1650,6 @@ tcp_test_session (vlib_main_t * vm, unformat_input_t * input) { int rv = 0; tcp_connection_t *tc0; - u8 sst = SESSION_TYPE_IP4_TCP; ip4_address_t local, remote; u16 local_port, remote_port; tcp_main_t *tm = vnet_get_tcp_main (); @@ -1692,7 +1691,7 @@ tcp_test_session (vlib_main_t * vm, unformat_input_t * input) TCP_EVT_DBG (TCP_EVT_OPEN, tc0); if (stream_session_accept (&tc0->connection, 0 /* listener index */ , - sst, 0 /* notify */ )) + 0 /* notify */ )) clib_warning ("stream_session_accept failed"); stream_session_accept_notify (&tc0->connection); diff --git a/src/vnet/udp/builtin_server.c b/src/vnet/udp/builtin_server.c index 7dd036709ec..23f0854fb53 100644 --- a/src/vnet/udp/builtin_server.c +++ b/src/vnet/udp/builtin_server.c @@ -115,7 +115,9 @@ attach_builtin_uri_server () a->options = options; - return vnet_application_attach (a); + if (vnet_application_attach (a)) + return -1; + return 0; } static int diff --git a/src/vnet/udp/udp_input.c b/src/vnet/udp/udp_input.c index 6ccb1e52942..5d3a1855269 100644 --- a/src/vnet/udp/udp_input.c +++ b/src/vnet/udp/udp_input.c @@ -121,9 +121,9 @@ udp4_uri_input_node_fn (vlib_main_t * vm, s0 = 0; /* lookup session */ - s0 = stream_session_lookup4 (&ip0->dst_address, &ip0->src_address, - udp0->dst_port, udp0->src_port, - SESSION_TYPE_IP4_UDP); + s0 = session_lookup4 (0, &ip0->dst_address, &ip0->src_address, + udp0->dst_port, udp0->src_port, + TRANSPORT_PROTO_UDP); /* no listener */ if (PREDICT_FALSE (s0 == 0)) @@ -186,7 +186,6 @@ udp4_uri_input_node_fn (vlib_main_t * vm, * create stream session and attach the udp session to it */ rv = stream_session_accept (&us->connection, s0->session_index, - SESSION_TYPE_IP4_UDP, 1 /*notify */ ); if (rv) error0 = rv; |