X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fapplication.c;h=65d2f08ddcad7db107f0801dd16c5781023add52;hb=61ae056bd;hp=954b934c1388a20c5ba4bd5f7f0caaa71f2fcfbf;hpb=ba7d8f5a3d4078d673486fbb91fe0ce87dfe7230;p=vpp.git

diff --git a/src/vnet/session/application.c b/src/vnet/session/application.c
index 954b934c138..65d2f08ddca 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;
 }
 
@@ -51,50 +52,15 @@ 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 (app, app_listener_index);
+  return al->ls_handle;
 }
 
 app_listener_t *
@@ -108,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 *
@@ -124,7 +100,6 @@ app_listener_lookup (application_t * app, session_endpoint_cfg_t * sep_ext)
   u32 table_index, fib_proto;
   session_endpoint_t *sep;
   session_handle_t handle;
-  local_session_t *ll;
   session_t *ls;
 
   sep = (session_endpoint_t *) sep_ext;
@@ -134,13 +109,13 @@ app_listener_lookup (application_t * app, session_endpoint_cfg_t * sep_ext)
       handle = session_lookup_endpoint_listener (table_index, sep, 1);
       if (handle != SESSION_INVALID_HANDLE)
 	{
-	  ll = application_get_local_listener_w_handle (handle);
-	  return app_listener_get_w_session ((session_t *) ll);
+	  ls = listen_session_get_from_handle (handle);
+	  return app_listener_get_w_session (ls);
 	}
     }
 
   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)
     {
@@ -157,11 +132,11 @@ app_listener_alloc_and_init (application_t * app,
 			     app_listener_t ** listener)
 {
   app_listener_t *app_listener;
-  local_session_t *ll = 0;
+  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);
@@ -175,18 +150,31 @@ app_listener_alloc_and_init (application_t * app,
   if (application_has_local_scope (app)
       && session_endpoint_is_local ((session_endpoint_t *) sep))
     {
-      u32 table_index;
+      session_type_t local_st;
+
+      local_st = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE,
+						 sep->is_ip4);
+      ls = listen_session_alloc (0, local_st);
+      ls->app_index = app->app_index;
+      ls->app_wrk_index = sep->app_wrk_index;
+      lh = session_handle (ls);
+
+      if ((rv = session_listen (ls, sep)))
+	{
+	  ls = session_get_from_handle (lh);
+	  session_free (ls);
+	  return rv;
+	}
+
+      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;
 
-      ll = application_local_listen_session_alloc (app);
-      ll->port = sep->port;
-      /* Store the original session type for the unbind */
-      ll->listener_session_type = st;
       table_index = application_local_session_table (app);
-      lh = application_local_session_handle (ll);
       session_lookup_add_session_endpoint (table_index,
 					   (session_endpoint_t *) sep, lh);
-      app_listener->local_index = ll->session_index;
-      ll->al_index = app_listener->al_index;
     }
 
   if (application_has_global_scope (app))
@@ -203,21 +191,40 @@ app_listener_alloc_and_init (application_t * app,
 
       /* Listen pool can be reallocated if the transport is
        * recursive (tls) */
-      lh = session_handle (ls);
+      lh = listen_session_get_handle (ls);
 
       if ((rv = session_listen (ls, sep)))
 	{
-	  ls = session_get_from_handle (lh);
+	  ls = listen_session_get_from_handle (lh);
 	  session_free (ls);
 	  return rv;
 	}
-      ls = session_get_from_handle (lh);
+      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.
+       * Lookup table needs to be populated only now because sessions
+       * with cut-through transport are are added to app local tables that
+       * are not related to network fibs, i.e., cannot be added as
+       * connections */
+      tc = session_get_transport (ls);
+      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;
@@ -231,32 +238,32 @@ void
 app_listener_cleanup (app_listener_t * al)
 {
   application_t *app = application_get (al->app_index);
+  session_t *ls;
 
   if (al->session_index != SESSION_INVALID_INDEX)
     {
-      session_t *ls = session_get (al->session_index, 0);
+      ls = session_get (al->session_index, 0);
       session_stop_listen (ls);
       listen_session_free (ls);
     }
   if (al->local_index != SESSION_INVALID_INDEX)
     {
       session_endpoint_t sep = SESSION_ENDPOINT_NULL;
-      local_session_t *ll;
       u32 table_index;
 
       table_index = application_local_session_table (app);
-      ll = application_get_local_listen_session (app, al->local_index);
-      application_local_listener_session_endpoint (ll, &sep);
+      ls = listen_session_get (al->local_index);
+      ct_session_endpoint (ls, &sep);
       session_lookup_del_session_endpoint (table_index, &sep);
-      application_local_listen_session_free (app, ll);
+      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);
@@ -278,6 +285,14 @@ app_listener_get_session (app_listener_t * al)
   return listen_session_get (al->session_index);
 }
 
+session_t *
+app_listener_get_local_session (app_listener_t * al)
+{
+  if (al->local_index == SESSION_INVALID_INDEX)
+    return 0;
+  return listen_session_get (al->local_index);
+}
+
 static app_worker_map_t *
 app_worker_map_alloc (application_t * app)
 {
@@ -448,14 +463,14 @@ application_verify_cfg (ssvm_segment_type_t st)
   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;
@@ -468,7 +483,7 @@ static int
 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;
@@ -478,7 +493,11 @@ application_alloc_and_init (app_init_args_t * a)
   /*
    * Make sure we support the requested configuration
    */
-  if (!(options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN))
+  if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN)
+    {
+      seg_type = SSVM_SEGMENT_PRIVATE;
+    }
+  else if (!a->use_sock_api)
     {
       reg = vl_api_client_index_to_registration (a->api_client_index);
       if (!reg)
@@ -486,20 +505,22 @@ application_alloc_and_init (app_init_args_t * a)
       if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
 	seg_type = SSVM_SEGMENT_SHM;
     }
-  else
+
+  if ((options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
+      && seg_type != SSVM_SEGMENT_MEMFD)
     {
-      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;
+      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;
 
+  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);
 
@@ -515,9 +536,10 @@ application_alloc_and_init (app_init_args_t * a)
     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];
@@ -533,6 +555,14 @@ application_alloc_and_init (app_init_args_t * a)
     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 */
@@ -544,7 +574,7 @@ application_alloc_and_init (app_init_args_t * a)
   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;
 }
@@ -554,16 +584,12 @@ application_free (application_t * app)
 {
   app_worker_map_t *wrk_map;
   app_worker_t *app_wrk;
-  u32 table_index;
-  local_session_t *ll;
-  session_endpoint_t sep;
 
   /*
    * 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);
@@ -580,29 +606,12 @@ application_free (application_t * app)
   /* *INDENT-ON* */
   pool_free (app->worker_maps);
 
-  /*
-   * Free local listeners. Global table unbinds stop local listeners
-   * as well, but if we have only local binds, these won't be cleaned up.
-   * Don't bother with local accepted sessions, we clean them when
-   * cleaning up the worker.
-   */
-  table_index = application_local_session_table (app);
-  /* *INDENT-OFF* */
-  pool_foreach (ll, app->local_listen_sessions, ({
-    application_local_listener_session_endpoint (ll, &sep);
-    session_lookup_del_session_endpoint (table_index, &sep);
-  }));
-  /* *INDENT-ON* */
-  pool_free (app->local_listen_sessions);
-
   /*
    * 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);
 }
 
@@ -621,7 +630,7 @@ application_detach_process (application_t * app, u32 api_client_index)
     }
 
   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, ({
@@ -675,10 +684,12 @@ application_n_workers (application_t * app)
 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
@@ -697,11 +708,10 @@ application_alloc_worker_and_init (application_t * app, app_worker_t ** wrk)
   /*
    * 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;
@@ -716,14 +726,6 @@ application_alloc_worker_and_init (application_t * app, app_worker_t ** wrk)
   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;
@@ -732,7 +734,7 @@ application_alloc_worker_and_init (application_t * app, app_worker_t ** wrk)
 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;
@@ -807,11 +809,11 @@ app_name_from_api_index (u32 api_client_index)
   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");
 }
 
 /**
@@ -824,7 +826,7 @@ app_name_from_api_index (u32 api_client_index)
 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;
@@ -843,16 +845,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;
@@ -967,19 +974,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
@@ -988,9 +997,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;
     }
@@ -1014,17 +1023,13 @@ vnet_listen (vnet_listen_args_t * a)
 int
 vnet_connect (vnet_connect_args_t * a)
 {
-  app_worker_t *server_wrk, *client_wrk;
+  app_worker_t *client_wrk;
   application_t *client;
-  local_session_t *ll;
-  app_listener_t *al;
-  u32 table_index;
-  session_t *ls;
-  u8 fib_proto;
-  u64 lh;
+
+  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 */ );
@@ -1037,60 +1042,19 @@ vnet_connect (vnet_connect_args_t * a)
    */
   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;
+      int rv;
 
-      ll = application_get_local_listener_w_handle (lh);
-      al = app_listener_get_w_session ((session_t *) ll);
-
-      /*
-       * 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, ll,
-					       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;
-
-  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);
-      ll = (local_session_t *) ls;
-      return app_worker_local_session_connect (client_wrk, server_wrk, ll,
-					       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;
+      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
@@ -1100,21 +1064,25 @@ 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 SESSION_E_NOLISTEN;
 
-  al = app_listener_get_w_handle (a->handle);
   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);
@@ -1123,52 +1091,21 @@ vnet_unlisten (vnet_unlisten_args_t * a)
 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;
-	}
+  app_worker_t *app_wrk;
+  session_t *s;
 
-      return app_worker_local_session_disconnect (wrk_index, ls);
-    }
-  else
-    {
-      app_worker_t *app_wrk;
-      session_t *s;
+  s = session_get_from_handle_if_valid (a->handle);
+  if (!s)
+    return SESSION_E_NOSESSION;
 
-      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;
+  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));
+  /* 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;
 }
 
@@ -1178,19 +1115,19 @@ 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
       && 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 -1;
+    return SESSION_E_NOAPP;
 
   app_listener = app_listener_get (app, s->al_index);
 
@@ -1198,8 +1135,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;
 
@@ -1236,12 +1173,6 @@ application_has_global_scope (application_t * 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)
@@ -1276,7 +1207,7 @@ application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
 
 	  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
@@ -1382,13 +1313,13 @@ application_remove_proxy (application_t * app)
   /* *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);
@@ -1398,24 +1329,20 @@ application_get_segment_manager_properties (u32 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;
 }
 
@@ -1468,65 +1395,68 @@ application_format_connects (application_t * app, int verbose)
   /* *INDENT-ON* */
 }
 
-static void
-application_format_local_sessions (application_t * app, int verbose)
-{
-  vlib_main_t *vm = vlib_get_main ();
-  app_worker_map_t *wrk_map;
-  app_worker_t *app_wrk;
-  transport_proto_t tp;
-  local_session_t *ls;
-  u8 *conn = 0;
+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 listeners
-   */
-
-  /* *INDENT-OFF* */
-  pool_foreach (ls, app->local_listen_sessions, ({
-    tp = session_type_transport_proto (ls->listener_session_type);
-    conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
-                   ls->port);
-    vlib_cli_output (vm, "%-40v%-15u%-20s", conn, ls->app_wrk_index, "*");
-    vec_reset_length (conn);
-  }));
-  /* *INDENT-ON* */
-
-  /*
-   * 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 *
@@ -1534,7 +1464,7 @@ 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;
@@ -1551,12 +1481,12 @@ format_application (u8 * s, va_list * args)
   props = application_segment_manager_properties (app);
   if (!verbose)
     {
-      s = format (s, "%-10u%-20s%-40s", app->app_index, app_name,
+      s = format (s, "%-10u%-20v%-40v", 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",
@@ -1574,7 +1504,7 @@ format_application (u8 * s, va_list * args)
 }
 
 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;
 
@@ -1584,29 +1514,17 @@ application_format_all_listeners (vlib_main_t * vm, int do_local, int verbose)
       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;
 
@@ -1616,33 +1534,72 @@ application_format_all_clients (vlib_main_t * vm, int do_local, int verbose)
       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;
@@ -1655,8 +1612,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, "local"))
-	do_local = 1;
+      else if (unformat (input, "mq"))
+	do_mq = 1;
       else if (unformat (input, "%u", &app_index))
 	;
       else if (unformat (input, "verbose"))
@@ -1666,15 +1623,31 @@ 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, 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;
     }
 
@@ -1702,15 +1675,123 @@ show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
   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;
+  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
  *