X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fapplication.c;h=d3e598ca271818fe05eaf07fb31190b57a4e2377;hb=98078ab88d93de4e44427c018cd3a74fc0ce8234;hp=30957870860ff763590d5b460ee00eb2e893fac9;hpb=ba65ca496af5766932a762bb99a758dbfcb580ec;p=vpp.git

diff --git a/src/vnet/session/application.c b/src/vnet/session/application.c
index 30957870860..d3e598ca271 100644
--- a/src/vnet/session/application.c
+++ b/src/vnet/session/application.c
@@ -38,6 +38,7 @@ app_listener_alloc (application_t * app)
   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;
 }
 
@@ -47,62 +48,19 @@ app_listener_get (application_t * app, u32 app_listener_index)
   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 *
@@ -116,14 +74,24 @@ app_listener_get_w_session (session_t * ls)
   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 *
@@ -133,6 +101,8 @@ app_listener_lookup (application_t * app, session_endpoint_cfg_t * sep_ext)
   session_endpoint_t *sep;
   session_handle_t handle;
   session_t *ls;
+  void *iface_ip;
+  ip46_address_t original_ip;
 
   sep = (session_endpoint_t *) sep_ext;
   if (application_has_local_scope (app) && session_endpoint_is_local (sep))
@@ -147,7 +117,7 @@ app_listener_lookup (application_t * app, session_endpoint_cfg_t * sep_ext)
     }
 
   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)
     {
@@ -155,6 +125,30 @@ app_listener_lookup (application_t * app, session_endpoint_cfg_t * sep_ext)
       return app_listener_get_w_session ((session_t *) ls);
     }
 
+  /*
+   * When binds to "inaddr_any", we add zero address in the local lookup table
+   * and interface address in the global lookup table. If local scope disable,
+   * the latter is the only clue to find the listener.
+   */
+  if (!application_has_local_scope (app) &&
+      ip_is_zero (&sep_ext->ip, sep_ext->is_ip4) &&
+      sep_ext->sw_if_index != ENDPOINT_INVALID_INDEX)
+    {
+      if ((iface_ip = ip_interface_get_first_ip (sep_ext->sw_if_index,
+						 sep_ext->is_ip4)))
+	{
+	  ip_copy (&original_ip, &sep_ext->ip, sep_ext->is_ip4);
+	  ip_set (&sep_ext->ip, iface_ip, sep_ext->is_ip4);
+	  handle = session_lookup_endpoint_listener (table_index, sep, 1);
+	  ip_copy (&sep_ext->ip, &original_ip, sep_ext->is_ip4);
+	  if (handle != SESSION_INVALID_HANDLE)
+	    {
+	      ls = listen_session_get_from_handle (handle);
+	      return app_listener_get_w_session ((session_t *) ls);
+	    }
+	}
+    }
+
   return 0;
 }
 
@@ -165,10 +159,10 @@ app_listener_alloc_and_init (application_t * app,
 {
   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);
@@ -183,7 +177,6 @@ app_listener_alloc_and_init (application_t * 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);
@@ -202,6 +195,7 @@ app_listener_alloc_and_init (application_t * app,
       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);
@@ -234,6 +228,7 @@ app_listener_alloc_and_init (application_t * 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.
@@ -242,7 +237,17 @@ app_listener_alloc_and_init (application_t * app,
        * 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);
+	  /* Assume namespace vetted previously so make sure table exists */
+	  table_index = session_lookup_get_or_alloc_index_for_fib (
+	    fib_proto, sep->fib_index);
+	  session_lookup_add_session_endpoint (table_index,
+					       (session_endpoint_t *) sep,
+					       lh);
+	}
     }
 
   if (!ls)
@@ -433,6 +438,264 @@ application_lookup_name (const u8 * name)
   return 0;
 }
 
+void
+appsl_pending_rx_mqs_add_tail (appsl_wrk_t *aw, app_rx_mq_elt_t *elt)
+{
+  app_rx_mq_elt_t *head;
+
+  if (!aw->pending_rx_mqs)
+    {
+      elt->next = elt->prev = elt;
+      aw->pending_rx_mqs = elt;
+      return;
+    }
+
+  head = aw->pending_rx_mqs;
+
+  ASSERT (head != elt);
+
+  elt->prev = head->prev;
+  elt->next = head;
+
+  head->prev->next = elt;
+  head->prev = elt;
+}
+
+void
+appsl_pending_rx_mqs_del (appsl_wrk_t *aw, app_rx_mq_elt_t *elt)
+{
+  if (elt->next == elt)
+    {
+      elt->next = elt->prev = 0;
+      aw->pending_rx_mqs = 0;
+      return;
+    }
+
+  if (elt == aw->pending_rx_mqs)
+    aw->pending_rx_mqs = elt->next;
+
+  elt->next->prev = elt->prev;
+  elt->prev->next = elt->next;
+  elt->next = elt->prev = 0;
+}
+
+vlib_node_registration_t appsl_rx_mqs_input_node;
+
+VLIB_NODE_FN (appsl_rx_mqs_input_node)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
+{
+  u32 thread_index = vm->thread_index, n_msgs = 0;
+  app_rx_mq_elt_t *elt, *next;
+  app_main_t *am = &app_main;
+  session_worker_t *wrk;
+  int __clib_unused rv;
+  appsl_wrk_t *aw;
+  u64 buf;
+
+  aw = &am->wrk[thread_index];
+  elt = aw->pending_rx_mqs;
+  if (!elt)
+    return 0;
+
+  wrk = session_main_get_worker (thread_index);
+
+  do
+    {
+      if (!(elt->flags & APP_RX_MQ_F_POSTPONED))
+	rv = read (svm_msg_q_get_eventfd (elt->mq), &buf, sizeof (buf));
+      n_msgs += session_wrk_handle_mq (wrk, elt->mq);
+
+      next = elt->next;
+      appsl_pending_rx_mqs_del (aw, elt);
+      if (!svm_msg_q_is_empty (elt->mq))
+	{
+	  elt->flags |= APP_RX_MQ_F_POSTPONED;
+	  appsl_pending_rx_mqs_add_tail (aw, elt);
+	}
+      else
+	{
+	  elt->flags = 0;
+	}
+      elt = next;
+    }
+  while (aw->pending_rx_mqs && elt != aw->pending_rx_mqs);
+
+  if (aw->pending_rx_mqs)
+    vlib_node_set_interrupt_pending (vm, appsl_rx_mqs_input_node.index);
+
+  if (n_msgs && wrk->state == SESSION_WRK_INTERRUPT)
+    vlib_node_set_interrupt_pending (vm, session_queue_node.index);
+
+  return n_msgs;
+}
+
+VLIB_REGISTER_NODE (appsl_rx_mqs_input_node) = {
+  .name = "appsl-rx-mqs-input",
+  .type = VLIB_NODE_TYPE_INPUT,
+  .state = VLIB_NODE_STATE_DISABLED,
+};
+
+static clib_error_t *
+app_rx_mq_fd_read_ready (clib_file_t *cf)
+{
+  app_rx_mq_handle_t *handle = (app_rx_mq_handle_t *) &cf->private_data;
+  vlib_main_t *vm = vlib_get_main ();
+  app_main_t *am = &app_main;
+  app_rx_mq_elt_t *mqe;
+  application_t *app;
+  appsl_wrk_t *aw;
+
+  ASSERT (vlib_get_thread_index () == handle->thread_index);
+  app = application_get_if_valid (handle->app_index);
+  if (!app)
+    return 0;
+
+  mqe = &app->rx_mqs[handle->thread_index];
+  if ((mqe->flags & APP_RX_MQ_F_PENDING) || svm_msg_q_is_empty (mqe->mq))
+    return 0;
+
+  aw = &am->wrk[handle->thread_index];
+  appsl_pending_rx_mqs_add_tail (aw, mqe);
+  mqe->flags |= APP_RX_MQ_F_PENDING;
+
+  vlib_node_set_interrupt_pending (vm, appsl_rx_mqs_input_node.index);
+
+  return 0;
+}
+
+static clib_error_t *
+app_rx_mq_fd_write_ready (clib_file_t *cf)
+{
+  clib_warning ("should not be called");
+  return 0;
+}
+
+static void
+app_rx_mqs_epoll_add (application_t *app, app_rx_mq_elt_t *mqe)
+{
+  clib_file_t template = { 0 };
+  app_rx_mq_handle_t handle;
+  u32 thread_index;
+  int fd;
+
+  thread_index = mqe - app->rx_mqs;
+  fd = svm_msg_q_get_eventfd (mqe->mq);
+
+  handle.app_index = app->app_index;
+  handle.thread_index = thread_index;
+
+  template.read_function = app_rx_mq_fd_read_ready;
+  template.write_function = app_rx_mq_fd_write_ready;
+  template.file_descriptor = fd;
+  template.private_data = handle.as_u64;
+  template.polling_thread_index = thread_index;
+  template.description =
+    format (0, "app-%u-rx-mq-%u", app->app_index, thread_index);
+  mqe->file_index = clib_file_add (&file_main, &template);
+}
+
+static void
+app_rx_mqs_epoll_del (application_t *app, app_rx_mq_elt_t *mqe)
+{
+  u32 thread_index = mqe - app->rx_mqs;
+  app_main_t *am = &app_main;
+  appsl_wrk_t *aw;
+
+  aw = &am->wrk[thread_index];
+
+  session_wrk_handle_mq (session_main_get_worker (thread_index), mqe->mq);
+
+  if (mqe->flags & APP_RX_MQ_F_PENDING)
+    appsl_pending_rx_mqs_del (aw, mqe);
+
+  clib_file_del_by_index (&file_main, mqe->file_index);
+}
+
+svm_msg_q_t *
+application_rx_mq_get (application_t *app, u32 mq_index)
+{
+  if (!app->rx_mqs)
+    return 0;
+
+  return app->rx_mqs[mq_index].mq;
+}
+
+static int
+app_rx_mqs_alloc (application_t *app)
+{
+  u32 evt_q_length, evt_size = sizeof (session_event_t);
+  fifo_segment_t *eqs = &app->rx_mqs_segment;
+  u32 n_mqs = vlib_num_workers () + 1;
+  segment_manager_props_t *props;
+  int i;
+
+  props = application_segment_manager_properties (app);
+  evt_q_length = clib_max (props->evt_q_size, 128);
+
+  svm_msg_q_cfg_t _cfg, *cfg = &_cfg;
+  svm_msg_q_ring_cfg_t rc[SESSION_MQ_N_RINGS] = {
+    { evt_q_length, evt_size, 0 }, { evt_q_length >> 1, 256, 0 }
+  };
+  cfg->consumer_pid = 0;
+  cfg->n_rings = 2;
+  cfg->q_nitems = evt_q_length;
+  cfg->ring_cfgs = rc;
+
+  eqs->ssvm.ssvm_size = svm_msg_q_size_to_alloc (cfg) * n_mqs + (1 << 20);
+  eqs->ssvm.name = format (0, "%s-rx-mqs-seg%c", app->name, 0);
+
+  if (ssvm_server_init (&eqs->ssvm, SSVM_SEGMENT_MEMFD))
+    {
+      clib_warning ("failed to initialize queue segment");
+      return SESSION_E_SEG_CREATE;
+    }
+
+  fifo_segment_init (eqs);
+
+  /* Fifo segment filled only with mqs */
+  eqs->h->n_mqs = n_mqs;
+  vec_validate (app->rx_mqs, n_mqs - 1);
+
+  for (i = 0; i < n_mqs; i++)
+    {
+      app->rx_mqs[i].mq = fifo_segment_msg_q_alloc (eqs, i, cfg);
+      if (svm_msg_q_alloc_eventfd (app->rx_mqs[i].mq))
+	{
+	  clib_warning ("eventfd returned");
+	  fifo_segment_cleanup (eqs);
+	  ssvm_delete (&eqs->ssvm);
+	  return SESSION_E_EVENTFD_ALLOC;
+	}
+      app_rx_mqs_epoll_add (app, &app->rx_mqs[i]);
+      app->rx_mqs[i].app_index = app->app_index;
+    }
+
+  return 0;
+}
+
+u8
+application_use_private_rx_mqs (void)
+{
+  return session_main.use_private_rx_mqs;
+}
+
+fifo_segment_t *
+application_get_rx_mqs_segment (application_t *app)
+{
+  if (application_use_private_rx_mqs ())
+    return &app->rx_mqs_segment;
+  return session_main_get_evt_q_segment ();
+}
+
+void
+application_enable_rx_mqs_nodes (u8 is_en)
+{
+  u8 state = is_en ? VLIB_NODE_STATE_INTERRUPT : VLIB_NODE_STATE_DISABLED;
+
+  foreach_vlib_main ()
+    vlib_node_set_state (this_vlib_main, appsl_rx_mqs_input_node.index, state);
+}
+
 static application_t *
 application_alloc (void)
 {
@@ -505,30 +768,20 @@ application_alloc_and_init (app_init_args_t * a)
 {
   ssvm_segment_type_t seg_type = SSVM_SEGMENT_MEMFD;
   segment_manager_props_t *props;
-  vl_api_registration_t *reg;
   application_t *app;
-  u64 *options;
+  u64 *opts;
 
   app = application_alloc ();
-  options = a->options;
+  opts = a->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 ((opts[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN) &&
+      !(opts[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_MEMFD_FOR_BUILTIN))
+    seg_type = SSVM_SEGMENT_PRIVATE;
 
-  if ((options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
-      && seg_type != SSVM_SEGMENT_MEMFD)
+  if ((opts[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");
@@ -538,13 +791,17 @@ application_alloc_and_init (app_init_args_t * a)
   if (!application_verify_cfg (seg_type))
     return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
 
+  if (opts[APP_OPTIONS_PREALLOC_FIFO_PAIRS] &&
+      opts[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 = options[APP_OPTIONS_FLAGS];
+  app->flags = opts[APP_OPTIONS_FLAGS];
   app->cb_fns = *a->session_cb_vft;
-  app->ns_index = options[APP_OPTIONS_NAMESPACE];
-  app->proxied_transports = options[APP_OPTIONS_PROXY_TRANSPORT];
+  app->ns_index = opts[APP_OPTIONS_NAMESPACE];
+  app->proxied_transports = opts[APP_OPTIONS_PROXY_TRANSPORT];
   app->name = vec_dup (a->name);
 
   /* If no scope enabled, default to global */
@@ -554,23 +811,32 @@ application_alloc_and_init (app_init_args_t * a)
 
   props = application_segment_manager_properties (app);
   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->segment_size = opts[APP_OPTIONS_SEGMENT_SIZE];
+  props->prealloc_fifos = opts[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
+  props->prealloc_fifo_hdrs = opts[APP_OPTIONS_PREALLOC_FIFO_HDRS];
+  if (opts[APP_OPTIONS_ADD_SEGMENT_SIZE])
     {
-      props->add_segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
+      props->add_segment_size = opts[APP_OPTIONS_ADD_SEGMENT_SIZE];
       props->add_segment = 1;
     }
-  if (options[APP_OPTIONS_RX_FIFO_SIZE])
-    props->rx_fifo_size = options[APP_OPTIONS_RX_FIFO_SIZE];
-  if (options[APP_OPTIONS_TX_FIFO_SIZE])
-    props->tx_fifo_size = options[APP_OPTIONS_TX_FIFO_SIZE];
-  if (options[APP_OPTIONS_EVT_QUEUE_SIZE])
-    props->evt_q_size = options[APP_OPTIONS_EVT_QUEUE_SIZE];
-  if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
+  if (opts[APP_OPTIONS_RX_FIFO_SIZE])
+    props->rx_fifo_size = opts[APP_OPTIONS_RX_FIFO_SIZE];
+  if (opts[APP_OPTIONS_TX_FIFO_SIZE])
+    props->tx_fifo_size = opts[APP_OPTIONS_TX_FIFO_SIZE];
+  if (opts[APP_OPTIONS_EVT_QUEUE_SIZE])
+    props->evt_q_size = opts[APP_OPTIONS_EVT_QUEUE_SIZE];
+  if (opts[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
     props->use_mq_eventfd = 1;
-  if (options[APP_OPTIONS_TLS_ENGINE])
-    app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
+  if (opts[APP_OPTIONS_TLS_ENGINE])
+    app->tls_engine = opts[APP_OPTIONS_TLS_ENGINE];
+  if (opts[APP_OPTIONS_MAX_FIFO_SIZE])
+    props->max_fifo_size = opts[APP_OPTIONS_MAX_FIFO_SIZE];
+  if (opts[APP_OPTIONS_HIGH_WATERMARK])
+    props->high_watermark = opts[APP_OPTIONS_HIGH_WATERMARK];
+  if (opts[APP_OPTIONS_LOW_WATERMARK])
+    props->low_watermark = opts[APP_OPTIONS_LOW_WATERMARK];
+  if (opts[APP_OPTIONS_PCT_FIRST_ALLOC])
+    props->pct_first_alloc = opts[APP_OPTIONS_PCT_FIRST_ALLOC];
   props->segment_type = seg_type;
 
   /* Add app to lookup by api_client_index table */
@@ -614,14 +880,26 @@ application_free (application_t * app)
   /* *INDENT-ON* */
   pool_free (app->worker_maps);
 
+  /*
+   * Free rx mqs if allocated
+   */
+  if (app->rx_mqs)
+    {
+      int i;
+      for (i = 0; i < vec_len (app->rx_mqs); i++)
+	app_rx_mqs_epoll_del (app, &app->rx_mqs[i]);
+
+      fifo_segment_cleanup (&app->rx_mqs_segment);
+      ssvm_delete (&app->rx_mqs_segment.ssvm);
+      vec_free (app->rx_mqs);
+    }
+
   /*
    * Cleanup remaining state
    */
   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);
 }
 
@@ -643,11 +921,11 @@ application_detach_process (application_t * app, u32 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))
@@ -721,8 +999,7 @@ application_alloc_worker_and_init (application_t * app, app_worker_t ** wrk)
   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;
@@ -732,7 +1009,7 @@ application_alloc_worker_and_init (application_t * app, app_worker_t ** wrk)
   /*
    * Setup app worker
    */
-  app_wrk->first_segment_manager = segment_manager_index (sm);
+  app_wrk->connects_seg_manager = segment_manager_index (sm);
   app_wrk->listeners_table = hash_create (0, sizeof (u64));
   app_wrk->event_queue = segment_manager_event_queue (sm);
   app_wrk->app_is_builtin = application_is_builtin (app);
@@ -765,7 +1042,7 @@ vnet_app_worker_add_del (vnet_app_worker_add_del_args_t * a)
       app_wrk->api_client_index = a->api_client_index;
       application_api_table_add (app->app_index, a->api_client_index);
 
-      sm = segment_manager_get (app_wrk->first_segment_manager);
+      sm = segment_manager_get (app_wrk->connects_seg_manager);
       fs = segment_manager_get_segment_w_lock (sm, 0);
       a->segment = &fs->ssvm;
       a->segment_handle = segment_manager_segment_handle (sm, fs);
@@ -784,6 +1061,8 @@ vnet_app_worker_add_del (vnet_app_worker_add_del_args_t * a)
 	return VNET_API_ERROR_INVALID_VALUE;
 
       application_api_table_del (app_wrk->api_client_index);
+      if (appns_sapi_enabled ())
+	sapi_socket_close_w_handle (app_wrk->api_client_index);
       app_worker_free (app_wrk);
       app_worker_map_free (app, wrk_map);
       if (application_n_workers (app) == 0)
@@ -856,16 +1135,21 @@ vnet_application_attach (vnet_app_attach_args_t * a)
   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;
@@ -876,19 +1160,28 @@ vnet_application_attach (vnet_app_attach_args_t * a)
 
   a->app_evt_q = app_wrk->event_queue;
   app_wrk->api_client_index = a->api_client_index;
-  sm = segment_manager_get (app_wrk->first_segment_manager);
+  sm = segment_manager_get (app_wrk->connects_seg_manager);
   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->connects_seg_manager);
+    }
 
   ASSERT (vec_len (fs->ssvm.name) <= 128);
   a->segment = &fs->ssvm;
   a->segment_handle = segment_manager_segment_handle (sm, fs);
 
   segment_manager_segment_reader_unlock (sm);
+
+  if (!application_is_builtin (app) && application_use_private_rx_mqs ())
+    rv = app_rx_mqs_alloc (app);
+
   vec_free (app_name);
-  return 0;
+  return rv;
 }
 
 /**
@@ -980,19 +1273,21 @@ vnet_listen (vnet_listen_args_t * a)
   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
@@ -1001,9 +1296,9 @@ vnet_listen (vnet_listen_args_t * a)
   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;
     }
@@ -1030,13 +1325,17 @@ vnet_connect (vnet_connect_args_t * a)
   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 */ );
   client_wrk = application_get_worker (client, a->wrk_map_index);
 
+  a->sep_ext.opaque = a->api_context;
+
   /*
    * First check the local scope for locally attached destinations.
    * If we have local scope, we pass *all* connects through it since we may
@@ -1048,16 +1347,15 @@ vnet_connect (vnet_connect_args_t * a)
 
       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)
+      rv = app_worker_connect_session (client_wrk, &a->sep_ext, &a->sh);
+      a->sep_ext.transport_proto = a->sep_ext.original_tp;
+      if (!rv || rv != SESSION_E_LOCAL_CONNECT)
 	return rv;
     }
   /*
    * 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_ext, &a->sh);
 }
 
 int
@@ -1067,28 +1365,51 @@ vnet_unlisten (vnet_unlisten_args_t * a)
   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);
 }
 
+int
+vnet_shutdown_session (vnet_shutdown_args_t *a)
+{
+  app_worker_t *app_wrk;
+  session_t *s;
+
+  s = session_get_from_handle_if_valid (a->handle);
+  if (!s)
+    return SESSION_E_NOSESSION;
+
+  app_wrk = app_worker_get (s->app_wrk_index);
+  if (app_wrk->app_index != a->app_index)
+    return SESSION_E_OWNER;
+
+  /* We're peeking into another's thread pool. Make sure */
+  ASSERT (s->session_index == session_index_from_handle (a->handle));
+
+  session_half_close (s);
+  return 0;
+}
+
 int
 vnet_disconnect_session (vnet_disconnect_args_t * a)
 {
@@ -1097,10 +1418,11 @@ vnet_disconnect_session (vnet_disconnect_args_t * a)
 
   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));
@@ -1115,9 +1437,10 @@ application_change_listener_owner (session_t * s, app_worker_t * app_wrk)
   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
@@ -1126,7 +1449,7 @@ application_change_listener_owner (session_t * s, app_worker_t * app_wrk)
 
   app = application_get (old_wrk->app_index);
   if (!app)
-    return -1;
+    return SESSION_E_NOAPP;
 
   app_listener = app_listener_get (app, s->al_index);
 
@@ -1134,8 +1457,8 @@ application_change_listener_owner (session_t * s, app_worker_t * app_wrk)
   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;
 
@@ -1325,30 +1648,6 @@ application_get_segment_manager_properties (u32 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)
 {
@@ -1366,7 +1665,7 @@ 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;
@@ -1374,7 +1673,7 @@ application_format_listeners (application_t * app, int verbose)
       vlib_cli_output (vm, "%U", format_app_worker_listener, app_wrk,
                        handle, sm_index, verbose);
     }));
-  }));
+  }
   /* *INDENT-ON* */
 }
 
@@ -1391,13 +1690,77 @@ application_format_connects (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);
     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)
 {
@@ -1420,7 +1783,7 @@ format_application (u8 * s, va_list * args)
   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;
     }
@@ -1433,10 +1796,10 @@ format_application (u8 * s, va_list * args)
 	      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;
@@ -1456,9 +1819,9 @@ application_format_all_listeners (vlib_main_t * vm, int verbose)
   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* */
 }
 
@@ -1476,17 +1839,75 @@ application_format_all_clients (vlib_main_t * vm, int verbose)
   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;
+  int i;
+
+  /* *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* */
+
+  for (i = 0; i < vec_len (app->rx_mqs); i++)
+    vlib_cli_output (vm, "[A%d][R%d]%U", app->app_index, i, format_svm_msg_q,
+		     app->rx_mqs[i].mq);
+}
+
+static clib_error_t *
+appliction_format_all_app_mq (vlib_main_t * vm)
+{
+  application_t *app;
+  int i, n_threads;
+
+  n_threads = vlib_get_n_threads ();
+
+  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;
@@ -1499,6 +1920,8 @@ show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
 	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"))
@@ -1508,6 +1931,22 @@ show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
 				  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);
@@ -1535,24 +1974,142 @@ show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
     {
       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)
+{
+  app_main_t *am = &app_main;
+  u32 n_workers;
+
+  n_workers = vlib_num_workers ();
+
+  /* Index 0 was originally used by legacy apis, maintain as invalid */
+  (void) app_cert_key_pair_alloc ();
+  am->last_crypto_engine = CRYPTO_ENGINE_LAST;
+  am->app_by_name = hash_create_vec (0, sizeof (u8), sizeof (uword));
+
+  vec_validate (am->wrk, n_workers);
+
+  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
  *