app_listener->app_index = app->app_index;
app_listener->session_index = SESSION_INVALID_INDEX;
app_listener->local_index = SESSION_INVALID_INDEX;
+ app_listener->ls_handle = SESSION_INVALID_HANDLE;
return app_listener;
}
app_listener_free (application_t * app, app_listener_t * app_listener)
{
clib_bitmap_free (app_listener->workers);
- pool_put (app->listeners, app_listener);
if (CLIB_DEBUG)
clib_memset (app_listener, 0xfa, sizeof (*app_listener));
-}
-
-static u32
-app_listener_id (app_listener_t * al)
-{
- ASSERT (al->app_index < 1 << 16 && al->al_index < 1 << 16);
- return (al->app_index << 16 | al->al_index);
+ pool_put (app->listeners, app_listener);
}
session_handle_t
app_listener_handle (app_listener_t * al)
{
- return ((u64) SESSION_LISTENER_PREFIX << 32 | (u64) app_listener_id (al));
-}
-
-static void
-app_listener_id_parse (u32 listener_id, u32 * app_index,
- u32 * app_listener_index)
-{
- *app_index = listener_id >> 16;
- *app_listener_index = listener_id & 0xFFFF;
-}
-
-void
-app_listener_handle_parse (session_handle_t handle, u32 * app_index,
- u32 * app_listener_index)
-{
- app_listener_id_parse (handle & 0xFFFFFFFF, app_index, app_listener_index);
-}
-
-static app_listener_t *
-app_listener_get_w_id (u32 listener_id)
-{
- u32 app_index, app_listener_index;
- application_t *app;
-
- app_listener_id_parse (listener_id, &app_index, &app_listener_index);
- app = application_get_if_valid (app_index);
- if (!app)
- return 0;
- return app_listener_get (app, app_listener_index);
+ return al->ls_handle;
}
app_listener_t *
return app_listener_get (app, ls->al_index);
}
+session_handle_t
+app_listen_session_handle (session_t * ls)
+{
+ app_listener_t *al;
+ al = app_listener_get_w_session (ls);
+ if (!al)
+ return listen_session_get_handle (ls);
+ return al->ls_handle;
+}
+
app_listener_t *
app_listener_get_w_handle (session_handle_t handle)
{
-
- if (handle >> 32 != SESSION_LISTENER_PREFIX)
+ session_t *ls;
+ ls = session_get_from_handle_if_valid (handle);
+ if (!ls)
return 0;
-
- return app_listener_get_w_id (handle & 0xFFFFFFFF);
+ return app_listener_get_w_session (ls);
}
app_listener_t *
}
fib_proto = session_endpoint_fib_proto (sep);
- table_index = application_session_table (app, fib_proto);
+ table_index = session_lookup_get_index_for_fib (fib_proto, sep->fib_index);
handle = session_lookup_endpoint_listener (table_index, sep, 1);
if (handle != SESSION_INVALID_HANDLE)
{
{
app_listener_t *app_listener;
transport_connection_t *tc;
- local_session_t *ll = 0;
+ u32 al_index, table_index;
session_handle_t lh;
session_type_t st;
session_t *ls = 0;
- u32 al_index;
int rv;
app_listener = app_listener_alloc (app);
&& session_endpoint_is_local ((session_endpoint_t *) sep))
{
session_type_t local_st;
- u32 table_index;
local_st = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE,
sep->is_ip4);
ls = session_get_from_handle (lh);
app_listener = app_listener_get (app, al_index);
app_listener->local_index = ls->session_index;
+ app_listener->ls_handle = lh;
ls->al_index = al_index;
table_index = application_local_session_table (app);
ls = listen_session_get_from_handle (lh);
app_listener = app_listener_get (app, al_index);
app_listener->session_index = ls->session_index;
+ app_listener->ls_handle = lh;
ls->al_index = al_index;
/* Add to the global lookup table after transport was initialized.
* are not related to network fibs, i.e., cannot be added as
* connections */
tc = session_get_transport (ls);
- session_lookup_add_connection (tc, lh);
+ if (!(tc->flags & TRANSPORT_CONNECTION_F_NO_LOOKUP))
+ {
+ fib_protocol_t fib_proto;
+ fib_proto = session_endpoint_fib_proto ((session_endpoint_t *) sep);
+ table_index = session_lookup_get_index_for_fib (fib_proto,
+ sep->fib_index);
+ ASSERT (table_index != SESSION_TABLE_INVALID_INDEX);
+ session_lookup_add_session_endpoint (table_index,
+ (session_endpoint_t *) sep,
+ lh);
+ }
}
- if (!ll && !ls)
+ if (!ls)
{
app_listener_free (app, app_listener);
return -1;
table_index = application_local_session_table (app);
ls = listen_session_get (al->local_index);
- application_local_listener_session_endpoint (ls, &sep);
+ ct_session_endpoint (ls, &sep);
session_lookup_del_session_endpoint (table_index, &sep);
+ session_stop_listen (ls);
listen_session_free (ls);
}
app_listener_free (app, al);
}
-app_worker_t *
-app_listener_select_worker (app_listener_t * al)
+static app_worker_t *
+app_listener_select_worker (application_t * app, app_listener_t * al)
{
- application_t *app;
u32 wrk_index;
app = application_get (al->app_index);
u8 is_valid;
if (st == SSVM_SEGMENT_MEMFD)
{
- is_valid = (session_manager_get_evt_q_segment () != 0);
+ is_valid = (session_main_get_evt_q_segment () != 0);
if (!is_valid)
clib_warning ("memfd seg: vpp's event qs IN binary api svm region");
return is_valid;
}
else if (st == SSVM_SEGMENT_SHM)
{
- is_valid = (session_manager_get_evt_q_segment () == 0);
+ is_valid = (session_main_get_evt_q_segment () == 0);
if (!is_valid)
clib_warning ("shm seg: vpp's event qs NOT IN binary api svm region");
return is_valid;
application_alloc_and_init (app_init_args_t * a)
{
ssvm_segment_type_t seg_type = SSVM_SEGMENT_MEMFD;
- segment_manager_properties_t *props;
+ segment_manager_props_t *props;
vl_api_registration_t *reg;
application_t *app;
u64 *options;
}
else
{
- if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
- {
- clib_warning ("mq eventfds can only be used if socket transport is "
- "used for api");
- return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
- }
seg_type = SSVM_SEGMENT_PRIVATE;
}
+ if ((options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
+ && seg_type != SSVM_SEGMENT_MEMFD)
+ {
+ clib_warning ("mq eventfds can only be used if socket transport is "
+ "used for binary api");
+ return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
+ }
+
if (!application_verify_cfg (seg_type))
return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
props = application_segment_manager_properties (app);
- segment_manager_properties_init (props);
- props->segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
+ segment_manager_props_init (props);
+ props->segment_size = options[APP_OPTIONS_SEGMENT_SIZE];
props->prealloc_fifos = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
if (options[APP_OPTIONS_ADD_SEGMENT_SIZE])
{
props->use_mq_eventfd = 1;
if (options[APP_OPTIONS_TLS_ENGINE])
app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
+ if (options[APP_OPTIONS_MAX_FIFO_SIZE])
+ props->max_fifo_size = options[APP_OPTIONS_MAX_FIFO_SIZE];
+ if (options[APP_OPTIONS_HIGH_WATERMARK])
+ props->high_watermark = options[APP_OPTIONS_HIGH_WATERMARK];
+ if (options[APP_OPTIONS_LOW_WATERMARK])
+ props->low_watermark = options[APP_OPTIONS_LOW_WATERMARK];
+ if (options[APP_OPTIONS_PCT_FIRST_ALLOC])
+ props->pct_first_alloc = options[APP_OPTIONS_PCT_FIRST_ALLOC];
props->segment_type = seg_type;
/* Add app to lookup by api_client_index table */
a->app_index = app->app_index;
APP_DBG ("New app name: %v api index: %u index %u", app->name,
- app->api_client_index, app->app_index);
+ a->api_client_index, app->app_index);
return 0;
}
* The app event queue allocated in first segment is cleared with
* the segment manager. No need to explicitly free it.
*/
- APP_DBG ("Delete app name %v api index: %d index: %d", app->name,
- app->api_client_index, app->app_index);
+ APP_DBG ("Delete app name %v index: %d", app->name, app->app_index);
if (application_is_proxy (app))
application_remove_proxy (app);
if (application_is_builtin (app))
application_name_table_del (app);
vec_free (app->name);
- vec_free (app->tls_cert);
- vec_free (app->tls_key);
pool_put (app_main.app_pool, app);
}
}
APP_DBG ("Detaching for app %v index %u api client index %u", app->name,
- app->app_index, app->api_client_index);
+ app->app_index, api_client_index);
/* *INDENT-OFF* */
pool_foreach (wrk_map, app->worker_maps, ({
app_worker_t *
application_listener_select_worker (session_t * ls)
{
+ application_t *app;
app_listener_t *al;
- al = app_listener_get_w_session (ls);
- return app_listener_select_worker (al);
+ app = application_get (ls->app_index);
+ al = app_listener_get (app, ls->al_index);
+ return app_listener_select_worker (app, al);
}
int
/*
* Setup first segment manager
*/
- sm = segment_manager_new ();
+ sm = segment_manager_alloc ();
sm->app_wrk_index = app_wrk->wrk_index;
- if ((rv = segment_manager_init (sm, app->sm_properties.segment_size,
- app->sm_properties.prealloc_fifos)))
+ if ((rv = segment_manager_init (sm)))
{
app_worker_free (app_wrk);
return rv;
app_wrk->event_queue = segment_manager_event_queue (sm);
app_wrk->app_is_builtin = application_is_builtin (app);
- /*
- * Segment manager for local sessions
- */
- sm = segment_manager_new ();
- sm->app_wrk_index = app_wrk->wrk_index;
- app_wrk->local_segment_manager = segment_manager_index (sm);
- app_wrk->local_connects = hash_create (0, sizeof (u64));
-
*wrk = app_wrk;
return 0;
int
vnet_app_worker_add_del (vnet_app_worker_add_del_args_t * a)
{
- svm_fifo_segment_private_t *fs;
+ fifo_segment_t *fs;
app_worker_map_t *wrk_map;
app_worker_t *app_wrk;
segment_manager_t *sm;
vl_api_registration_t *regp;
regp = vl_api_client_index_to_registration (api_client_index);
if (regp)
- return format (0, "%s%c", regp->name, 0);
+ return format (0, "%s", regp->name);
clib_warning ("api client index %u does not have an api registration!",
api_client_index);
- return format (0, "unknown%c", 0);
+ return format (0, "unknown");
}
/**
int
vnet_application_attach (vnet_app_attach_args_t * a)
{
- svm_fifo_segment_private_t *fs;
+ fifo_segment_t *fs;
application_t *app = 0;
app_worker_t *app_wrk;
segment_manager_t *sm;
application_t *app;
int rv;
+ ASSERT (vlib_thread_is_main_w_barrier ());
+
app = application_get_if_valid (a->app_index);
if (!app)
return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
int
vnet_connect (vnet_connect_args_t * a)
{
- app_worker_t *server_wrk, *client_wrk;
+ app_worker_t *client_wrk;
application_t *client;
- app_listener_t *al;
- u32 table_index;
- session_t *ls;
- u8 fib_proto;
- session_handle_t lh;
+
+ ASSERT (vlib_thread_is_main_w_barrier ());
if (session_endpoint_is_zero (&a->sep))
return VNET_API_ERROR_INVALID_VALUE;
*/
if (application_has_local_scope (client))
{
- table_index = application_local_session_table (client);
- lh = session_lookup_local_endpoint (table_index, &a->sep);
- if (lh == SESSION_DROP_HANDLE)
- return VNET_API_ERROR_APP_CONNECT_FILTERED;
-
- if (lh == SESSION_INVALID_HANDLE)
- goto global_scope;
-
- ls = listen_session_get_from_handle (lh);
- al = app_listener_get_w_session (ls);
-
- /*
- * Break loop if rule in local table points to connecting app. This
- * can happen if client is a generic proxy. Route connect through
- * global table instead.
- */
- if (al->app_index == a->app_index)
- goto global_scope;
-
- server_wrk = app_listener_select_worker (al);
- return app_worker_local_session_connect (client_wrk, server_wrk, ls,
- a->api_context);
- }
-
- /*
- * If nothing found, check the global scope for locally attached
- * destinations. Make sure first that we're allowed to.
- */
-
-global_scope:
- if (session_endpoint_is_local (&a->sep))
- return VNET_API_ERROR_SESSION_CONNECT;
-
- if (!application_has_global_scope (client))
- return VNET_API_ERROR_APP_CONNECT_SCOPE;
+ int rv;
- fib_proto = session_endpoint_fib_proto (&a->sep);
- table_index = application_session_table (client, fib_proto);
- ls = session_lookup_listener (table_index, &a->sep);
- if (ls)
- {
- al = app_listener_get_w_session (ls);
- server_wrk = app_listener_select_worker (al);
- return app_worker_local_session_connect (client_wrk, server_wrk, ls,
- a->api_context);
+ a->sep_ext.original_tp = a->sep_ext.transport_proto;
+ a->sep_ext.transport_proto = TRANSPORT_PROTO_NONE;
+ rv = app_worker_connect_session (client_wrk, &a->sep, a->api_context);
+ if (rv <= 0)
+ return rv;
}
-
/*
* Not connecting to a local server, propagate to transport
*/
app_listener_t *al;
application_t *app;
+ ASSERT (vlib_thread_is_main_w_barrier ());
+
if (!(app = application_get_if_valid (a->app_index)))
return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
- al = app_listener_get_w_handle (a->handle);
+ if (!(al = app_listener_get_w_handle (a->handle)))
+ return -1;
+
if (al->app_index != app->app_index)
{
clib_warning ("app doesn't own handle %llu!", a->handle);
int
vnet_disconnect_session (vnet_disconnect_args_t * a)
{
- if (session_handle_is_local (a->handle))
- {
- app_worker_t *client_wrk, *server_wrk;
- local_session_t *ls;
- u32 wrk_index = ~0;
-
- /* Disconnect reply came to worker 1 not main thread */
- app_interface_check_thread_and_barrier (vnet_disconnect_session, a);
-
- if (!(ls = app_worker_get_local_session_from_handle (a->handle)))
- return 0;
-
- client_wrk = app_worker_get_if_valid (ls->client_wrk_index);
- server_wrk = app_worker_get (ls->app_wrk_index);
-
- if (server_wrk->app_index == a->app_index)
- wrk_index = server_wrk->wrk_index;
- else if (client_wrk && client_wrk->app_index == a->app_index)
- wrk_index = client_wrk->wrk_index;
-
- if (wrk_index == ~0)
- {
- clib_warning ("app %u does not own session 0x%lx", a->app_index,
- application_local_session_handle (ls));
- return VNET_API_ERROR_INVALID_VALUE;
- }
-
- return app_worker_local_session_disconnect (wrk_index, ls);
- }
- else
- {
- app_worker_t *app_wrk;
- session_t *s;
+ app_worker_t *app_wrk;
+ session_t *s;
- s = session_get_from_handle_if_valid (a->handle);
- if (!s)
- return VNET_API_ERROR_INVALID_VALUE;
- app_wrk = app_worker_get (s->app_wrk_index);
- if (app_wrk->app_index != a->app_index)
- return VNET_API_ERROR_INVALID_VALUE;
+ s = session_get_from_handle_if_valid (a->handle);
+ if (!s)
+ return VNET_API_ERROR_INVALID_VALUE;
+ app_wrk = app_worker_get (s->app_wrk_index);
+ if (app_wrk->app_index != a->app_index)
+ return VNET_API_ERROR_INVALID_VALUE;
- /* We're peeking into another's thread pool. Make sure */
- ASSERT (s->session_index == session_index_from_handle (a->handle));
+ /* We're peeking into another's thread pool. Make sure */
+ ASSERT (s->session_index == session_index_from_handle (a->handle));
- session_close (s);
- }
+ session_close (s);
return 0;
}
hash_unset (old_wrk->listeners_table, listen_session_get_handle (s));
if (session_transport_service_type (s) == TRANSPORT_SERVICE_CL
&& s->rx_fifo)
- segment_manager_dealloc_fifos (s->rx_fifo->segment_index, s->rx_fifo,
- s->tx_fifo);
+ segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo);
app = application_get (old_wrk->app_index);
if (!app)
return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
}
-u8
-application_use_mq_for_ctrl (application_t * app)
-{
- return app->flags & APP_OPTIONS_FLAGS_USE_MQ_FOR_CTRL_MSGS;
-}
-
static clib_error_t *
application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
u8 transport_proto, u8 is_start)
app_worker_start_listen (app_wrk, al);
s = listen_session_get (al->session_index);
- s->enqueue_epoch = SESSION_PROXY_LISTENER_INDEX;
+ s->flags |= SESSION_F_PROXY;
}
}
else
/* *INDENT-ON* */
}
-segment_manager_properties_t *
+segment_manager_props_t *
application_segment_manager_properties (application_t * app)
{
return &app->sm_properties;
}
-segment_manager_properties_t *
+segment_manager_props_t *
application_get_segment_manager_properties (u32 app_index)
{
application_t *app = application_get (app_index);
clib_error_t *
vnet_app_add_tls_cert (vnet_app_add_tls_cert_args_t * a)
{
- application_t *app;
- app = application_get (a->app_index);
- if (!app)
- return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
- 0, "app %u doesn't exist", a->app_index);
- app->tls_cert = vec_dup (a->cert);
+ /* Deprected, will be remove after 20.01 */
+ app_cert_key_pair_t *ckpair;
+ ckpair = app_cert_key_pair_get_default ();
+ ckpair->cert = vec_dup (a->cert);
return 0;
}
clib_error_t *
vnet_app_add_tls_key (vnet_app_add_tls_key_args_t * a)
{
- application_t *app;
- app = application_get (a->app_index);
- if (!app)
- return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
- 0, "app %u doesn't exist", a->app_index);
- app->tls_key = vec_dup (a->key);
+ /* Deprected, will be remove after 20.01 */
+ app_cert_key_pair_t *ckpair;
+ ckpair = app_cert_key_pair_get_default ();
+ ckpair->key = vec_dup (a->key);
return 0;
}
/* *INDENT-ON* */
}
-static void
-application_format_local_sessions (application_t * app, int verbose)
-{
- app_worker_map_t *wrk_map;
- app_worker_t *app_wrk;
+u8 *
+format_cert_key_pair (u8 * s, va_list * args)
+{
+ app_cert_key_pair_t *ckpair = va_arg (*args, app_cert_key_pair_t *);
+ int key_len = 0, cert_len = 0;
+ cert_len = vec_len (ckpair->cert);
+ key_len = vec_len (ckpair->key);
+ if (ckpair->cert_key_index == 0)
+ s = format (s, "DEFAULT (cert:%d, key:%d)", cert_len, key_len);
+ else
+ s = format (s, "%d (cert:%d, key:%d)", ckpair->cert_key_index,
+ cert_len, key_len);
+ return s;
+}
- if (!app)
+u8 *
+format_crypto_engine (u8 * s, va_list * args)
+{
+ u32 engine = va_arg (*args, u32);
+ switch (engine)
{
- app_worker_format_local_sessions (0, verbose);
- return;
+ case CRYPTO_ENGINE_NONE:
+ return format (s, "none");
+ case CRYPTO_ENGINE_MBEDTLS:
+ return format (s, "mbedtls");
+ case CRYPTO_ENGINE_OPENSSL:
+ return format (s, "openssl");
+ case CRYPTO_ENGINE_PICOTLS:
+ return format (s, "picotls");
+ case CRYPTO_ENGINE_VPP:
+ return format (s, "vpp");
+ default:
+ return format (s, "unknown engine");
}
-
- /*
- * Format local accepted/connected sessions
- */
- /* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
- app_wrk = app_worker_get (wrk_map->wrk_index);
- app_worker_format_local_sessions (app_wrk, verbose);
- }));
- /* *INDENT-ON* */
+ return s;
}
-static void
-application_format_local_connects (application_t * app, int verbose)
+uword
+unformat_crypto_engine (unformat_input_t * input, va_list * args)
{
- app_worker_map_t *wrk_map;
- app_worker_t *app_wrk;
-
- if (!app)
- {
- app_worker_format_local_connects (0, verbose);
- return;
- }
+ u8 *a = va_arg (*args, u8 *);
+ if (unformat (input, "mbedtls"))
+ *a = CRYPTO_ENGINE_MBEDTLS;
+ else if (unformat (input, "openssl"))
+ *a = CRYPTO_ENGINE_OPENSSL;
+ else if (unformat (input, "picotls"))
+ *a = CRYPTO_ENGINE_PICOTLS;
+ else if (unformat (input, "vpp"))
+ *a = CRYPTO_ENGINE_VPP;
+ else
+ return 0;
+ return 1;
+}
- /* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
- app_wrk = app_worker_get (wrk_map->wrk_index);
- app_worker_format_local_connects (app_wrk, verbose);
- }));
- /* *INDENT-ON* */
+u8 *
+format_crypto_context (u8 * s, va_list * args)
+{
+ crypto_context_t *crctx = va_arg (*args, crypto_context_t *);
+ s = format (s, "[0x%x][sub%d,ckpair%x]", crctx->ctx_index,
+ crctx->n_subscribers, crctx->ckpair_index);
+ s = format (s, "[%U]", format_crypto_engine, crctx->crypto_engine);
+ return s;
}
u8 *
{
application_t *app = va_arg (*args, application_t *);
CLIB_UNUSED (int verbose) = va_arg (*args, int);
- segment_manager_properties_t *props;
+ segment_manager_props_t *props;
const u8 *app_ns_name, *app_name;
app_worker_map_t *wrk_map;
app_worker_t *app_wrk;
props = application_segment_manager_properties (app);
if (!verbose)
{
- s = format (s, "%-10u%-20s%-40s", app->app_index, app_name,
+ s = format (s, "%-10u%-20v%-40s", app->app_index, app_name,
app_ns_name);
return s;
}
- s = format (s, "app-name %s app-index %u ns-index %u seg-size %U\n",
+ s = format (s, "app-name %v app-index %u ns-index %u seg-size %U\n",
app_name, app->app_index, app->ns_index,
format_memory_size, props->add_segment_size);
s = format (s, "rx-fifo-size %U tx-fifo-size %U workers:\n",
}
void
-application_format_all_listeners (vlib_main_t * vm, int do_local, int verbose)
+application_format_all_listeners (vlib_main_t * vm, int verbose)
{
application_t *app;
return;
}
- if (do_local)
- {
- application_format_local_sessions (0, verbose);
- /* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
- application_format_local_sessions (app, verbose);
- }));
- /* *INDENT-ON* */
- }
- else
- {
- application_format_listeners (0, verbose);
+ application_format_listeners (0, verbose);
- /* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
- application_format_listeners (app, verbose);
- }));
- /* *INDENT-ON* */
- }
+ /* *INDENT-OFF* */
+ pool_foreach (app, app_main.app_pool, ({
+ application_format_listeners (app, verbose);
+ }));
+ /* *INDENT-ON* */
}
void
-application_format_all_clients (vlib_main_t * vm, int do_local, int verbose)
+application_format_all_clients (vlib_main_t * vm, int verbose)
{
application_t *app;
return;
}
- if (do_local)
- {
- application_format_local_connects (0, verbose);
+ application_format_connects (0, verbose);
- /* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
- application_format_local_connects (app, verbose);
- }));
- /* *INDENT-ON* */
- }
- else
- {
- application_format_connects (0, verbose);
+ /* *INDENT-OFF* */
+ pool_foreach (app, app_main.app_pool, ({
+ application_format_connects (app, verbose);
+ }));
+ /* *INDENT-ON* */
+}
- /* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
- application_format_connects (app, verbose);
- }));
- /* *INDENT-ON* */
+static clib_error_t *
+show_certificate_command_fn (vlib_main_t * vm, unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ app_cert_key_pair_t *ckpair;
+ session_cli_return_if_not_enabled ();
+
+ /* *INDENT-OFF* */
+ pool_foreach (ckpair, app_main.cert_key_pair_store, ({
+ vlib_cli_output (vm, "%U", format_cert_key_pair, ckpair);
+ }));
+ /* *INDENT-ON* */
+ return 0;
+}
+
+static inline void
+appliction_format_app_mq (vlib_main_t * vm, application_t * app)
+{
+ app_worker_map_t *map;
+ app_worker_t *wrk;
+ /* *INDENT-OFF* */
+ pool_foreach (map, app->worker_maps, ({
+ wrk = app_worker_get (map->wrk_index);
+ vlib_cli_output (vm, "[A%d][%d]%U", app->app_index,
+ map->wrk_index, format_svm_msg_q,
+ wrk->event_queue);
+ }));
+ /* *INDENT-ON* */
+}
+
+static clib_error_t *
+appliction_format_all_app_mq (vlib_main_t * vm)
+{
+ application_t *app;
+ int i, n_threads;
+
+ n_threads = vec_len (vlib_mains);
+
+ for (i = 0; i < n_threads; i++)
+ {
+ vlib_cli_output (vm, "[Ctrl%d]%U", i, format_svm_msg_q,
+ session_main_get_vpp_event_queue (i));
}
+
+ /* *INDENT-OFF* */
+ pool_foreach (app, app_main.app_pool, ({
+ appliction_format_app_mq (vm, app);
+ }));
+ /* *INDENT-ON* */
+ return 0;
}
static clib_error_t *
show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
vlib_cli_command_t * cmd)
{
- int do_server = 0, do_client = 0, do_local = 0;
+ int do_server = 0, do_client = 0, do_mq = 0;
application_t *app;
u32 app_index = ~0;
int verbose = 0;
do_server = 1;
else if (unformat (input, "client"))
do_client = 1;
- else if (unformat (input, "local"))
- do_local = 1;
+ else if (unformat (input, "mq"))
+ do_mq = 1;
else if (unformat (input, "%u", &app_index))
;
else if (unformat (input, "verbose"))
format_unformat_error, input);
}
+ if (do_mq && app_index != ~0)
+ {
+ app = application_get_if_valid (app_index);
+ if (!app)
+ return clib_error_return (0, "No app with index %u", app_index);
+
+ appliction_format_app_mq (vm, app);
+ return 0;
+ }
+
+ if (do_mq)
+ {
+ appliction_format_all_app_mq (vm);
+ return 0;
+ }
+
if (do_server)
{
- application_format_all_listeners (vm, do_local, verbose);
+ application_format_all_listeners (vm, verbose);
return 0;
}
if (do_client)
{
- application_format_all_clients (vm, do_local, verbose);
+ application_format_all_clients (vm, verbose);
return 0;
}
return 0;
}
+/* Certificate store */
+
+static app_cert_key_pair_t *
+app_cert_key_pair_alloc ()
+{
+ app_cert_key_pair_t *ckpair;
+ pool_get (app_main.cert_key_pair_store, ckpair);
+ clib_memset (ckpair, 0, sizeof (*ckpair));
+ ckpair->cert_key_index = ckpair - app_main.cert_key_pair_store;
+ return ckpair;
+}
+
+app_cert_key_pair_t *
+app_cert_key_pair_get_if_valid (u32 index)
+{
+ if (pool_is_free_index (app_main.cert_key_pair_store, index))
+ return 0;
+ return app_cert_key_pair_get (index);
+}
+
+app_cert_key_pair_t *
+app_cert_key_pair_get (u32 index)
+{
+ return pool_elt_at_index (app_main.cert_key_pair_store, index);
+}
+
+app_cert_key_pair_t *
+app_cert_key_pair_get_default ()
+{
+ /* To maintain legacy bapi */
+ return app_cert_key_pair_get (0);
+}
+
+int
+vnet_app_add_cert_key_pair (vnet_app_add_cert_key_pair_args_t * a)
+{
+ app_cert_key_pair_t *ckpair = app_cert_key_pair_alloc ();
+ ckpair->cert = vec_dup (a->cert);
+ ckpair->key = vec_dup (a->key);
+ a->index = ckpair->cert_key_index;
+ return 0;
+}
+
+int
+vnet_app_add_cert_key_interest (u32 index, u32 app_index)
+{
+ app_cert_key_pair_t *ckpair;
+ if (!(ckpair = app_cert_key_pair_get_if_valid (index)))
+ return -1;
+ if (vec_search (ckpair->app_interests, app_index) != ~0)
+ vec_add1 (ckpair->app_interests, app_index);
+ return 0;
+}
+
+int
+vnet_app_del_cert_key_pair (u32 index)
+{
+ app_cert_key_pair_t *ckpair;
+ application_t *app;
+ u32 *app_index;
+
+ if (!(ckpair = app_cert_key_pair_get_if_valid (index)))
+ return (VNET_API_ERROR_INVALID_VALUE);
+
+ vec_foreach (app_index, ckpair->app_interests)
+ {
+ if ((app = application_get_if_valid (*app_index))
+ && app->cb_fns.app_cert_key_pair_delete_callback)
+ app->cb_fns.app_cert_key_pair_delete_callback (ckpair);
+ }
+
+ vec_free (ckpair->cert);
+ vec_free (ckpair->key);
+ pool_put (app_main.cert_key_pair_store, ckpair);
+ return 0;
+}
+
+clib_error_t *
+application_init (vlib_main_t * vm)
+{
+ /* Add a certificate with index 0 to support legacy apis */
+ (void) app_cert_key_pair_alloc ();
+ app_main.last_crypto_engine = CRYPTO_ENGINE_LAST;
+ return 0;
+}
+
/* *INDENT-OFF* */
+VLIB_INIT_FUNCTION (application_init);
+
VLIB_CLI_COMMAND (show_app_command, static) =
{
.path = "show app",
- .short_help = "show app [server|client] [verbose]",
+ .short_help = "show app [app_id] [server|client] [mq] [verbose]",
.function = show_app_command_fn,
};
+
+VLIB_CLI_COMMAND (show_certificate_command, static) =
+{
+ .path = "show app certificate",
+ .short_help = "list app certs and keys present in store",
+ .function = show_certificate_command_fn,
+};
/* *INDENT-ON* */
+crypto_engine_type_t
+app_crypto_engine_type_add (void)
+{
+ return (++app_main.last_crypto_engine);
+}
+
+u8
+app_crypto_engine_n_types (void)
+{
+ return (app_main.last_crypto_engine + 1);
+}
+
/*
* fd.io coding-style-patch-verification: ON
*