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;
}
return pool_elt_at_index (app->listeners, app_listener_index);
}
-static app_listener_t *
-app_listener_get_if_valid (application_t * app, u32 app_listener_index)
-{
- if (pool_is_free_index (app->listeners, app_listener_index))
- return 0;
- return pool_elt_at_index (app->listeners, app_listener_index);
-}
-
static void
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_if_valid (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;
+ 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 (!ls)
application_alloc_and_init (app_init_args_t * a)
{
ssvm_segment_type_t seg_type = SSVM_SEGMENT_MEMFD;
- segment_manager_properties_t *props;
- vl_api_registration_t *reg;
+ segment_manager_props_t *props;
application_t *app;
u64 *options;
/*
* Make sure we support the requested configuration
*/
- if (!(options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN))
- {
- reg = vl_api_client_index_to_registration (a->api_client_index);
- if (!reg)
- return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
- if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
- seg_type = SSVM_SEGMENT_SHM;
- }
- else
- {
- seg_type = SSVM_SEGMENT_PRIVATE;
- }
+ if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN)
+ seg_type = SSVM_SEGMENT_PRIVATE;
if ((options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
&& seg_type != SSVM_SEGMENT_MEMFD)
if (!application_verify_cfg (seg_type))
return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
+ if (options[APP_OPTIONS_PREALLOC_FIFO_PAIRS]
+ && options[APP_OPTIONS_PREALLOC_FIFO_HDRS])
+ return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
+
/* Check that the obvious things are properly set up */
application_verify_cb_fns (a->session_cb_vft);
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];
+ props->prealloc_fifo_hdrs = options[APP_OPTIONS_PREALLOC_FIFO_HDRS];
if (options[APP_OPTIONS_ADD_SEGMENT_SIZE])
{
props->add_segment_size = 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, ({
+ pool_foreach (wrk_map, app->worker_maps) {
app_wrk = app_worker_get (wrk_map->wrk_index);
if (app_wrk->api_client_index == api_client_index)
vec_add1 (wrks, app_wrk->wrk_index);
- }));
+ }
/* *INDENT-ON* */
if (!vec_len (wrks))
/*
* 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_first (sm)))
{
app_worker_free (app_wrk);
return rv;
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;
if (app)
return VNET_API_ERROR_APP_ALREADY_ATTACHED;
- if (a->api_client_index != APP_INVALID_INDEX)
+ /* Socket api sets the name and validates namespace prior to attach */
+ if (!a->use_sock_api)
{
- app_name = app_name_from_api_index (a->api_client_index);
- a->name = app_name;
- }
+ if (a->api_client_index != APP_INVALID_INDEX)
+ {
+ app_name = app_name_from_api_index (a->api_client_index);
+ a->name = app_name;
+ }
- secret = a->options[APP_OPTIONS_NAMESPACE_SECRET];
- if ((rv = app_validate_namespace (a->namespace_id, secret, &app_ns_index)))
- return rv;
- a->options[APP_OPTIONS_NAMESPACE] = app_ns_index;
+ secret = a->options[APP_OPTIONS_NAMESPACE_SECRET];
+ if ((rv = app_validate_namespace (a->namespace_id, secret,
+ &app_ns_index)))
+ return rv;
+ a->options[APP_OPTIONS_NAMESPACE] = app_ns_index;
+ }
if ((rv = application_alloc_and_init ((app_init_args_t *) a)))
return rv;
fs = segment_manager_get_segment_w_lock (sm, 0);
if (application_is_proxy (app))
- application_setup_proxy (app);
+ {
+ application_setup_proxy (app);
+ /* The segment manager pool is reallocated because a new listener
+ * is added. Re-grab segment manager to avoid dangling reference */
+ sm = segment_manager_get (app_wrk->first_segment_manager);
+ }
ASSERT (vec_len (fs->ssvm.name) <= 128);
a->segment = &fs->ssvm;
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;
+ return SESSION_E_NOAPP;
app_wrk = application_get_worker (app, a->wrk_map_index);
if (!app_wrk)
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_INVALID_APPWRK;
a->sep_ext.app_wrk_index = app_wrk->wrk_index;
session_endpoint_update_for_app (&a->sep_ext, app, 0 /* is_connect */ );
if (!session_endpoint_in_ns (&a->sep))
- return VNET_API_ERROR_INVALID_VALUE_2;
+ return SESSION_E_INVALID_NS;
/*
* Check if we already have an app listener
if (app_listener)
{
if (app_listener->app_index != app->app_index)
- return VNET_API_ERROR_ADDRESS_IN_USE;
- if (app_worker_start_listen (app_wrk, app_listener))
- return -1;
+ return SESSION_E_ALREADY_LISTENING;
+ if ((rv = app_worker_start_listen (app_wrk, app_listener)))
+ return rv;
a->handle = app_listener_handle (app_listener);
return 0;
}
app_worker_t *client_wrk;
application_t *client;
+ ASSERT (vlib_thread_is_main_w_barrier ());
+
if (session_endpoint_is_zero (&a->sep))
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_INVALID_RMT_IP;
client = application_get (a->app_index);
session_endpoint_update_for_app (&a->sep_ext, client, 1 /* is_connect */ );
rv = app_worker_connect_session (client_wrk, &a->sep, a->api_context);
if (rv <= 0)
return rv;
+ a->sep_ext.transport_proto = a->sep_ext.original_tp;
}
/*
* Not connecting to a local server, propagate to transport
*/
- if (app_worker_connect_session (client_wrk, &a->sep, a->api_context))
- return VNET_API_ERROR_SESSION_CONNECT;
- return 0;
+ return app_worker_connect_session (client_wrk, &a->sep, a->api_context);
}
int
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;
+ return SESSION_E_NOAPP;
if (!(al = app_listener_get_w_handle (a->handle)))
- return -1;
+ return SESSION_E_NOLISTEN;
if (al->app_index != app->app_index)
{
clib_warning ("app doesn't own handle %llu!", a->handle);
- return -1;
+ return SESSION_E_OWNER;
}
app_wrk = application_get_worker (app, a->wrk_map_index);
if (!app_wrk)
{
clib_warning ("no app %u worker %u", app->app_index, a->wrk_map_index);
- return -1;
+ return SESSION_E_INVALID_APPWRK;
}
return app_worker_stop_listen (app_wrk, al);
s = session_get_from_handle_if_valid (a->handle);
if (!s)
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_NOSESSION;
+
app_wrk = app_worker_get (s->app_wrk_index);
if (app_wrk->app_index != a->app_index)
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_OWNER;
/* We're peeking into another's thread pool. Make sure */
ASSERT (s->session_index == session_index_from_handle (a->handle));
app_worker_t *old_wrk = app_worker_get (s->app_wrk_index);
app_listener_t *app_listener;
application_t *app;
+ int rv;
if (!old_wrk)
- return -1;
+ return SESSION_E_INVALID_APPWRK;
hash_unset (old_wrk->listeners_table, listen_session_get_handle (s));
if (session_transport_service_type (s) == TRANSPORT_SERVICE_CL
app = application_get (old_wrk->app_index);
if (!app)
- return -1;
+ return SESSION_E_NOAPP;
app_listener = app_listener_get (app, s->al_index);
app_listener->workers = clib_bitmap_set (app_listener->workers,
old_wrk->wrk_map_index, 0);
- if (app_worker_start_listen (app_wrk, app_listener))
- return -1;
+ if ((rv = app_worker_start_listen (app_wrk, app_listener)))
+ return rv;
s->app_wrk_index = app_wrk->wrk_index;
/* *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);
return &app->sm_properties;
}
-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);
- 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);
- return 0;
-}
-
static void
application_format_listeners (application_t * app, int verbose)
{
}
/* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
+ pool_foreach (wrk_map, app->worker_maps) {
app_wrk = app_worker_get (wrk_map->wrk_index);
if (hash_elts (app_wrk->listeners_table) == 0)
continue;
vlib_cli_output (vm, "%U", format_app_worker_listener, app_wrk,
handle, sm_index, verbose);
}));
- }));
+ }
/* *INDENT-ON* */
}
}
/* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
+ pool_foreach (wrk_map, app->worker_maps) {
app_wrk = app_worker_get (wrk_map->wrk_index);
app_worker_format_connects (app_wrk, verbose);
- }));
+ }
/* *INDENT-ON* */
}
+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;
+}
+
+u8 *
+format_crypto_engine (u8 * s, va_list * args)
+{
+ u32 engine = va_arg (*args, u32);
+ switch (engine)
+ {
+ 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");
+ }
+ return s;
+}
+
+uword
+unformat_crypto_engine (unformat_input_t * input, va_list * args)
+{
+ 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;
+}
+
+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 *
format_application (u8 * s, va_list * args)
{
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%-20v%-40s", app->app_index, app_name,
+ s = format (s, "%-10u%-20v%-40v", app->app_index, app_name,
app_ns_name);
return s;
}
format_memory_size, props->tx_fifo_size);
/* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
+ pool_foreach (wrk_map, app->worker_maps) {
app_wrk = app_worker_get (wrk_map->wrk_index);
s = format (s, "%U", format_app_worker, app_wrk);
- }));
+ }
/* *INDENT-ON* */
return s;
application_format_listeners (0, verbose);
/* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
+ pool_foreach (app, app_main.app_pool) {
application_format_listeners (app, verbose);
- }));
+ }
/* *INDENT-ON* */
}
application_format_connects (0, verbose);
/* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
+ 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;
+ 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, "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, verbose);
{
vlib_cli_output (vm, "%U", format_application, 0, 0);
/* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
+ pool_foreach (app, app_main.app_pool) {
vlib_cli_output (vm, "%U", format_application, app, 0);
- }));
+ }
/* *INDENT-ON* */
}
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 ();
+ vec_validate (ckpair->cert, a->cert_len - 1);
+ clib_memcpy_fast (ckpair->cert, a->cert, a->cert_len);
+ vec_validate (ckpair->key, a->key_len - 1);
+ clib_memcpy_fast (ckpair->key, a->key, a->key_len);
+ 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)
+{
+ /* Index 0 was originally used by legacy apis, maintain as invalid */
+ (void) app_cert_key_pair_alloc ();
+ app_main.last_crypto_engine = CRYPTO_ENGINE_LAST;
+ app_main.app_by_name = hash_create_vec (0, sizeof (u8), sizeof (uword));
+ 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
*
Code Review / vpp.git / blobdiff