vcl: cleanup bapi and wrk registration

Type: refactor

Signed-off-by: Florin Coras <fcoras@cisco.com>
Change-Id: I0391db5c3ad038265cb8ebf9de02925653e35959

6 files changed, 360 insertions, 361 deletions

diff --git a/src/vcl/vcl_bapi.c b/src/vcl/vcl_bapi.c
index 0e034fc097d..d3a27acaced 100644
--- a/src/vcl/vcl_bapi.c
+++ b/src/vcl/vcl_bapi.c
@@ -58,7 +58,7 @@ static void
 		    format_api_error, ntohl (mp->retval));
     }
   else
-    vcm->app_state = STATE_APP_ENABLED;
+    vcm->bapi_app_state = STATE_APP_ENABLED;
 }
 
 static u64
@@ -141,11 +141,11 @@ vl_api_app_attach_reply_t_handler (vl_api_app_attach_reply_t * mp)
     }
 
   vcm->app_index = clib_net_to_host_u32 (mp->app_index);
-  vcm->app_state = STATE_APP_ATTACHED;
+  vcm->bapi_app_state = STATE_APP_ATTACHED;
   return;
 
 failed:
-  vcm->app_state = STATE_APP_FAILED;
+  vcm->bapi_app_state = STATE_APP_FAILED;
   for (i = clib_max (n_fds - 1, 0); i < vec_len (fds); i++)
     close (fds[i]);
   vec_free (fds);
@@ -231,12 +231,12 @@ vl_api_app_worker_add_del_reply_t_handler (vl_api_app_worker_add_del_reply_t *
       if (rv != 0)
 	goto failed;
     }
-  vcm->app_state = STATE_APP_READY;
+  vcm->bapi_app_state = STATE_APP_READY;
   VDBG (0, "worker %u vpp-worker %u added", wrk_index, wrk->vpp_wrk_index);
   return;
 
 failed:
-  vcm->app_state = STATE_APP_FAILED;
+  vcm->bapi_app_state = STATE_APP_FAILED;
   for (i = clib_max (n_fds - 1, 0); i < vec_len (fds); i++)
     close (fds[i]);
   vec_free (fds);
@@ -248,7 +248,7 @@ static void
 {
   if (mp->retval)
     VDBG (0, "add cert failed: %U", format_api_error, ntohl (mp->retval));
-  vcm->app_state = STATE_APP_READY;
+  vcm->bapi_app_state = STATE_APP_READY;
 }
 
 static void
@@ -257,7 +257,7 @@ static void
 {
   if (mp->retval)
     VDBG (0, "add key failed: %U", format_api_error, ntohl (mp->retval));
-  vcm->app_state = STATE_APP_READY;
+  vcm->bapi_app_state = STATE_APP_READY;
 }
 
 #define foreach_sock_msg                                        	\
@@ -267,8 +267,8 @@ _(APPLICATION_TLS_CERT_ADD_REPLY, application_tls_cert_add_reply)  	\
 _(APPLICATION_TLS_KEY_ADD_REPLY, application_tls_key_add_reply)  	\
 _(APP_WORKER_ADD_DEL_REPLY, app_worker_add_del_reply)			\
 
-void
-vppcom_api_hookup (void)
+static void
+vcl_bapi_hookup (void)
 {
 #define _(N, n)                                                	\
     vl_msg_api_set_handlers(VL_API_##N, #n,                    	\
@@ -284,8 +284,8 @@ vppcom_api_hookup (void)
 /*
  * VPP-API message functions
  */
-void
-vppcom_send_session_enable_disable (u8 is_enable)
+static void
+vcl_bapi_send_session_enable_disable (u8 is_enable)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_session_enable_disable_t *bmp;
@@ -293,14 +293,14 @@ vppcom_send_session_enable_disable (u8 is_enable)
   memset (bmp, 0, sizeof (*bmp));
 
   bmp->_vl_msg_id = ntohs (VL_API_SESSION_ENABLE_DISABLE);
-  bmp->client_index = wrk->my_client_index;
+  bmp->client_index = wrk->bapi_client_index;
   bmp->context = htonl (0xfeedface);
   bmp->is_enable = is_enable;
   vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & bmp);
 }
 
 void
-vppcom_app_send_attach (void)
+vcl_bapi_send_attach (void)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   u8 tls_engine = CRYPTO_ENGINE_OPENSSL;
@@ -315,7 +315,7 @@ vppcom_app_send_attach (void)
   memset (bmp, 0, sizeof (*bmp));
 
   bmp->_vl_msg_id = ntohs (VL_API_APP_ATTACH);
-  bmp->client_index = wrk->my_client_index;
+  bmp->client_index = wrk->bapi_client_index;
   bmp->context = htonl (0xfeedface);
   bmp->options[APP_OPTIONS_FLAGS] =
     APP_OPTIONS_FLAGS_ACCEPT_REDIRECT | APP_OPTIONS_FLAGS_ADD_SEGMENT |
@@ -343,7 +343,7 @@ vppcom_app_send_attach (void)
 }
 
 void
-vppcom_app_send_detach (void)
+vcl_bapi_send_detach (void)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_application_detach_t *bmp;
@@ -351,13 +351,13 @@ vppcom_app_send_detach (void)
   memset (bmp, 0, sizeof (*bmp));
 
   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
-  bmp->client_index = wrk->my_client_index;
+  bmp->client_index = wrk->bapi_client_index;
   bmp->context = htonl (0xfeedface);
   vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & bmp);
 }
 
-void
-vcl_send_app_worker_add_del (u8 is_add)
+static void
+vcl_bapi_send_app_worker_add_del (u8 is_add)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_app_worker_add_del_t *mp;
@@ -366,7 +366,7 @@ vcl_send_app_worker_add_del (u8 is_add)
   memset (mp, 0, sizeof (*mp));
 
   mp->_vl_msg_id = ntohs (VL_API_APP_WORKER_ADD_DEL);
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   mp->app_index = clib_host_to_net_u32 (vcm->app_index);
   mp->context = wrk->wrk_index;
   mp->is_add = is_add;
@@ -376,8 +376,8 @@ vcl_send_app_worker_add_del (u8 is_add)
   vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & mp);
 }
 
-void
-vcl_send_child_worker_del (vcl_worker_t * child_wrk)
+static void
+vcl_bapi_send_child_worker_del (vcl_worker_t * child_wrk)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_app_worker_add_del_t *mp;
@@ -386,7 +386,7 @@ vcl_send_child_worker_del (vcl_worker_t * child_wrk)
   memset (mp, 0, sizeof (*mp));
 
   mp->_vl_msg_id = ntohs (VL_API_APP_WORKER_ADD_DEL);
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   mp->app_index = clib_host_to_net_u32 (vcm->app_index);
   mp->context = wrk->wrk_index;
   mp->is_add = 0;
@@ -396,8 +396,8 @@ vcl_send_child_worker_del (vcl_worker_t * child_wrk)
 }
 
 void
-vppcom_send_application_tls_cert_add (vcl_session_t * session, char *cert,
-				      u32 cert_len)
+vcl_bapi_send_application_tls_cert_add (vcl_session_t * session, char *cert,
+					u32 cert_len)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_application_tls_cert_add_t *cert_mp;
@@ -405,7 +405,7 @@ vppcom_send_application_tls_cert_add (vcl_session_t * session, char *cert,
   cert_mp = vl_msg_api_alloc (sizeof (*cert_mp) + cert_len);
   clib_memset (cert_mp, 0, sizeof (*cert_mp));
   cert_mp->_vl_msg_id = ntohs (VL_API_APPLICATION_TLS_CERT_ADD);
-  cert_mp->client_index = wrk->my_client_index;
+  cert_mp->client_index = wrk->bapi_client_index;
   cert_mp->context = session->session_index;
   cert_mp->cert_len = clib_host_to_net_u16 (cert_len);
   clib_memcpy_fast (cert_mp->cert, cert, cert_len);
@@ -413,8 +413,8 @@ vppcom_send_application_tls_cert_add (vcl_session_t * session, char *cert,
 }
 
 void
-vppcom_send_application_tls_key_add (vcl_session_t * session, char *key,
-				     u32 key_len)
+vcl_bapi_send_application_tls_key_add (vcl_session_t * session, char *key,
+				       u32 key_len)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_application_tls_key_add_t *key_mp;
@@ -422,7 +422,7 @@ vppcom_send_application_tls_key_add (vcl_session_t * session, char *key,
   key_mp = vl_msg_api_alloc (sizeof (*key_mp) + key_len);
   clib_memset (key_mp, 0, sizeof (*key_mp));
   key_mp->_vl_msg_id = ntohs (VL_API_APPLICATION_TLS_KEY_ADD);
-  key_mp->client_index = wrk->my_client_index;
+  key_mp->client_index = wrk->bapi_client_index;
   key_mp->context = session->session_index;
   key_mp->key_len = clib_host_to_net_u16 (key_len);
   clib_memcpy_fast (key_mp->key, key, key_len);
@@ -430,14 +430,14 @@ vppcom_send_application_tls_key_add (vcl_session_t * session, char *key,
 }
 
 u32
-vcl_max_nsid_len (void)
+vcl_bapi_max_nsid_len (void)
 {
   vl_api_app_attach_t *mp;
   return (sizeof (mp->namespace_id) - 1);
 }
 
-void
-vppcom_init_error_string_table (void)
+static void
+vcl_bapi_init_error_string_table (void)
 {
   vcm->error_string_by_error_number = hash_create (0, sizeof (uword));
 
@@ -448,75 +448,314 @@ vppcom_init_error_string_table (void)
   hash_set (vcm->error_string_by_error_number, 99, "Misc");
 }
 
-int
-vppcom_connect_to_vpp (const char *app_name)
+static void
+vcl_bapi_cleanup (void)
+{
+  socket_client_main_t *scm = &socket_client_main;
+  api_main_t *am = vlibapi_get_main ();
+
+  am->my_client_index = ~0;
+  am->my_registration = 0;
+  am->vl_input_queue = 0;
+  am->msg_index_by_name_and_crc = 0;
+  scm->socket_fd = 0;
+
+  vl_client_api_unmap ();
+}
+
+static int
+vcl_bapi_connect_to_vpp (void)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
+  int rv = VPPCOM_OK;
   api_main_t *am;
+  u8 *wrk_name;
+
+  wrk_name = format (0, "%s-wrk-%u%c", vcm->app_name, wrk->wrk_index, 0);
+
+  /* Make sure api is cleaned up in case this is a connect from a
+   * forked worker */
+  vcl_bapi_cleanup ();
 
   vlibapi_set_main (&wrk->bapi_api_ctx);
   vlibapi_set_memory_client_main (&wrk->bapi_shm_ctx);
-  vppcom_api_hookup ();
+  vcl_bapi_hookup ();
 
-  if (vcl_cfg->vpp_api_socket_name)
+  if (vcl_cfg->vpp_bapi_socket_name)
     {
       if (vl_socket_client_connect2 (&wrk->bapi_sock_ctx,
-				     (char *) vcl_cfg->vpp_api_socket_name,
-				     (char *) app_name,
+				     (char *) vcl_cfg->vpp_bapi_socket_name,
+				     (char *) wrk_name,
 				     0 /* default rx/tx buffer */ ))
 	{
-	  VERR ("app (%s) socket connect failed!", app_name);
-	  return VPPCOM_ECONNREFUSED;
+	  VERR ("app (%s) socket connect failed!", wrk_name);
+	  rv = VPPCOM_ECONNREFUSED;
+	  goto error;
 	}
 
       if (vl_socket_client_init_shm2 (&wrk->bapi_sock_ctx, 0,
 				      1 /* want_pthread */ ))
 	{
-	  VERR ("app (%s) init shm failed!", app_name);
-	  return VPPCOM_ECONNREFUSED;
+	  VERR ("app (%s) init shm failed!", wrk_name);
+	  rv = VPPCOM_ECONNREFUSED;
+	  goto error;
 	}
     }
   else
     {
-      if (!vcl_cfg->vpp_api_filename)
-	vcl_cfg->vpp_api_filename = format (0, "/vpe-api%c", 0);
+      if (!vcl_cfg->vpp_bapi_filename)
+	vcl_cfg->vpp_bapi_filename = format (0, "/vpe-api%c", 0);
 
-      vl_set_memory_root_path ((char *) vcl_cfg->vpp_api_chroot);
+      vl_set_memory_root_path ((char *) vcl_cfg->vpp_bapi_chroot);
 
       VDBG (0, "app (%s) connecting to VPP api (%s)...",
-	    app_name, vcl_cfg->vpp_api_filename);
+	    wrk_name, vcl_cfg->vpp_bapi_filename);
 
-      if (vl_client_connect_to_vlib ((char *) vcl_cfg->vpp_api_filename,
-				     app_name, vcm->cfg.vpp_api_q_length) < 0)
+      if (vl_client_connect_to_vlib ((char *) vcl_cfg->vpp_bapi_filename,
+				     (char *) wrk_name,
+				     vcm->cfg.vpp_api_q_length) < 0)
 	{
-	  VERR ("app (%s) connect failed!", app_name);
-	  return VPPCOM_ECONNREFUSED;
+	  VERR ("app (%s) connect failed!", wrk_name);
+	  rv = VPPCOM_ECONNREFUSED;
+	  goto error;
 	}
     }
 
   am = vlibapi_get_main ();
   wrk->vl_input_queue = am->shmem_hdr->vl_input_queue;
-  wrk->my_client_index = (u32) am->my_client_index;
-  wrk->wrk_state = STATE_APP_CONN_VPP;
+  wrk->bapi_client_index = (u32) am->my_client_index;
 
-  VDBG (0, "app (%s) is connected to VPP!", app_name);
+  VDBG (0, "app (%s) is connected to VPP!", wrk_name);
   vcl_evt (VCL_EVT_INIT, vcm);
-  return VPPCOM_OK;
+
+error:
+  vec_free (wrk_name);
+  return rv;
 }
 
 void
-vppcom_disconnect_from_vpp (void)
+vcl_bapi_disconnect_from_vpp (void)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
 
-  if (vcl_cfg->vpp_api_socket_name)
+  if (vcl_cfg->vpp_bapi_socket_name)
     vl_socket_client_disconnect2 (&wrk->bapi_sock_ctx);
   else
     vl_client_disconnect_from_vlib ();
 }
 
+static const char *
+vcl_bapi_app_state_str (vcl_bapi_app_state_t state)
+{
+  char *st;
+
+  switch (state)
+    {
+    case STATE_APP_START:
+      st = "STATE_APP_START";
+      break;
+
+    case STATE_APP_CONN_VPP:
+      st = "STATE_APP_CONN_VPP";
+      break;
+
+    case STATE_APP_ENABLED:
+      st = "STATE_APP_ENABLED";
+      break;
+
+    case STATE_APP_ATTACHED:
+      st = "STATE_APP_ATTACHED";
+      break;
+
+    default:
+      st = "UNKNOWN_APP_STATE";
+      break;
+    }
+
+  return st;
+}
+
+static int
+vcl_bapi_wait_for_app_state_change (vcl_bapi_app_state_t app_state)
+{
+  vcl_worker_t *wrk = vcl_worker_get_current ();
+  f64 timeout = clib_time_now (&wrk->clib_time) + vcm->cfg.app_timeout;
+
+  while (clib_time_now (&wrk->clib_time) < timeout)
+    {
+      if (vcm->bapi_app_state == app_state)
+	return VPPCOM_OK;
+      if (vcm->bapi_app_state == STATE_APP_FAILED)
+	return VPPCOM_ECONNABORTED;
+    }
+  VDBG (0, "timeout waiting for state %s (%d)",
+	vcl_bapi_app_state_str (app_state), app_state);
+  vcl_evt (VCL_EVT_SESSION_TIMEOUT, vcm, bapi_app_state);
+
+  return VPPCOM_ETIMEDOUT;
+}
+
+static int
+vcl_bapi_session_enable (void)
+{
+  int rv;
+
+  if (vcm->bapi_app_state != STATE_APP_ENABLED)
+    {
+      vcl_bapi_send_session_enable_disable (1 /* is_enabled == TRUE */ );
+      rv = vcl_bapi_wait_for_app_state_change (STATE_APP_ENABLED);
+      if (PREDICT_FALSE (rv))
+	{
+	  VDBG (0, "application session enable timed out! returning %d (%s)",
+		rv, vppcom_retval_str (rv));
+	  return rv;
+	}
+    }
+  return VPPCOM_OK;
+}
+
+static int
+vcl_bapi_init (void)
+{
+  int rv;
+
+  vcm->bapi_app_state = STATE_APP_START;
+  vcl_bapi_init_error_string_table ();
+  rv = vcl_bapi_connect_to_vpp ();
+  if (rv)
+    {
+      VERR ("couldn't connect to VPP!");
+      return rv;
+    }
+  VDBG (0, "sending session enable");
+  rv = vcl_bapi_session_enable ();
+  if (rv)
+    {
+      VERR ("vppcom_app_session_enable() failed!");
+      return rv;
+    }
+
+  return 0;
+}
+
+int
+vcl_bapi_attach (void)
+{
+  int rv;
+
+  /* API hookup and connect to VPP */
+  if ((rv = vcl_bapi_init ()))
+    return rv;
+
+  vcl_bapi_send_attach ();
+  rv = vcl_bapi_wait_for_app_state_change (STATE_APP_ATTACHED);
+  if (PREDICT_FALSE (rv))
+    {
+      VDBG (0, "application attach timed out! returning %d (%s)", rv,
+	    vppcom_retval_str (rv));
+      return rv;
+    }
+
+  return 0;
+}
+
+int
+vcl_bapi_app_worker_add (void)
+{
+  if (vcl_bapi_connect_to_vpp ())
+    return -1;
+
+  vcm->bapi_app_state = STATE_APP_ADDING_WORKER;
+  vcl_bapi_send_app_worker_add_del (1 /* is_add */ );
+  if (vcl_bapi_wait_for_app_state_change (STATE_APP_READY))
+    return -1;
+  return 0;
+}
+
+void
+vcl_bapi_app_worker_del (vcl_worker_t * wrk)
+{
+  /* Notify vpp that the worker is going away */
+  if (wrk->wrk_index == vcl_get_worker_index ())
+    vcl_bapi_send_app_worker_add_del (0 /* is_add */ );
+  else
+    vcl_bapi_send_child_worker_del (wrk);
+
+  /* Disconnect the binary api */
+  if (vec_len (vcm->workers) == 1)
+    vcl_bapi_disconnect_from_vpp ();
+  else
+    vl_client_send_disconnect (1 /* vpp should cleanup */ );
+}
+
+int
+vppcom_session_tls_add_cert (uint32_t session_handle, char *cert,
+			     uint32_t cert_len)
+{
+
+  vcl_worker_t *wrk = vcl_worker_get_current ();
+  vcl_session_t *session = 0;
+
+  session = vcl_session_get_w_handle (wrk, session_handle);
+  if (!session)
+    return VPPCOM_EBADFD;
+
+  if (cert_len == 0 || cert_len == ~0)
+    return VPPCOM_EBADFD;
+
+  /*
+   * Send listen request to vpp and wait for reply
+   */
+  vcl_bapi_send_application_tls_cert_add (session, cert, cert_len);
+  vcm->bapi_app_state = STATE_APP_ADDING_TLS_DATA;
+  vcl_bapi_wait_for_app_state_change (STATE_APP_READY);
+  return VPPCOM_OK;
+}
+
+int
+vppcom_session_tls_add_key (uint32_t session_handle, char *key,
+			    uint32_t key_len)
+{
+
+  vcl_worker_t *wrk = vcl_worker_get_current ();
+  vcl_session_t *session = 0;
+
+  session = vcl_session_get_w_handle (wrk, session_handle);
+  if (!session)
+    return VPPCOM_EBADFD;
+
+  if (key_len == 0 || key_len == ~0)
+    return VPPCOM_EBADFD;
+
+  vcl_bapi_send_application_tls_key_add (session, key, key_len);
+  vcm->bapi_app_state = STATE_APP_ADDING_TLS_DATA;
+  vcl_bapi_wait_for_app_state_change (STATE_APP_READY);
+  return VPPCOM_OK;
+}
+
+int
+vcl_bapi_worker_set (void)
+{
+  vcl_worker_t *wrk = vcl_worker_get_current ();
+  int i;
+
+  /* Find the first worker with the same pid */
+  for (i = 0; i < vec_len (vcm->workers); i++)
+    {
+      if (i == wrk->wrk_index)
+	continue;
+      if (vcm->workers[i].current_pid == wrk->current_pid)
+	{
+	  wrk->vl_input_queue = vcm->workers[i].vl_input_queue;
+	  wrk->bapi_client_index = vcm->workers[i].bapi_client_index;
+	  return 0;
+	}
+    }
+  return -1;
+}
+
 /*
  * fd.io coding-style-patch-verification: ON
  *
diff --git a/src/vcl/vcl_cfg.c b/src/vcl/vcl_cfg.c
index f7e271bbdc9..0900b318fce 100644
--- a/src/vcl/vcl_cfg.c
+++ b/src/vcl/vcl_cfg.c
@@ -283,18 +283,18 @@ vppcom_cfg_read_file (char *conf_fname)
 			vcl_cfg->max_workers);
 	    }
 	  else if (unformat (line_input, "api-prefix %s",
-			     &vcl_cfg->vpp_api_chroot))
+			     &vcl_cfg->vpp_bapi_chroot))
 	    {
-	      vec_terminate_c_string (vcl_cfg->vpp_api_chroot);
+	      vec_terminate_c_string (vcl_cfg->vpp_bapi_chroot);
 	      VCFG_DBG (0, "VCL<%d>: configured api-prefix (%s) ", getpid (),
-			vcl_cfg->vpp_api_chroot);
+			vcl_cfg->vpp_bapi_chroot);
 	    }
 	  else if (unformat (line_input, "api-socket-name %s",
-			     &vcl_cfg->vpp_api_socket_name))
+			     &vcl_cfg->vpp_bapi_socket_name))
 	    {
-	      vec_terminate_c_string (vcl_cfg->vpp_api_socket_name);
+	      vec_terminate_c_string (vcl_cfg->vpp_bapi_socket_name);
 	      VCFG_DBG (0, "VCL<%d>: configured api-socket-name (%s)",
-			getpid (), vcl_cfg->vpp_api_socket_name);
+			getpid (), vcl_cfg->vpp_bapi_socket_name);
 	    }
 	  else if (unformat (line_input, "vpp-api-q-length %d", &q_len))
 	    {
@@ -473,7 +473,7 @@ vppcom_cfg_read_file (char *conf_fname)
 	  else if (unformat (line_input, "namespace-id %v",
 			     &vcl_cfg->namespace_id))
 	    {
-	      u32 max_nsid_vec_len = vcl_max_nsid_len ();
+	      u32 max_nsid_vec_len = vcl_bapi_max_nsid_len ();
 	      u32 nsid_vec_len = vec_len (vcl_cfg->namespace_id);
 	      if (nsid_vec_len > max_nsid_vec_len)
 		{
@@ -567,8 +567,8 @@ vppcom_cfg (vppcom_cfg_t * vcl_cfg)
   env_var_str = getenv (VPPCOM_ENV_API_PREFIX);
   if (env_var_str)
     {
-      vcl_cfg->vpp_api_chroot = format (0, "%s", env_var_str);
-      vec_terminate_c_string (vcl_cfg->vpp_api_chroot);
+      vcl_cfg->vpp_bapi_chroot = format (0, "%s", env_var_str);
+      vec_terminate_c_string (vcl_cfg->vpp_bapi_chroot);
       VCFG_DBG (0, "VCL<%d>: configured api prefix (%s) from "
 		VPPCOM_ENV_API_PREFIX "!", getpid (), env_var_str);
     }
@@ -634,9 +634,9 @@ vppcom_cfg (vppcom_cfg_t * vcl_cfg)
   env_var_str = getenv (VPPCOM_ENV_VPP_API_SOCKET);
   if (env_var_str)
     {
-      vcm->cfg.vpp_api_socket_name = format (0, "%s%c", env_var_str, 0);
+      vcm->cfg.vpp_bapi_socket_name = format (0, "%s%c", env_var_str, 0);
       VCFG_DBG (0, "VCL<%d>: configured api-socket-name (%s)", getpid (),
-		vcl_cfg->vpp_api_socket_name);
+		vcl_cfg->vpp_bapi_socket_name);
     }
 }
 
diff --git a/src/vcl/vcl_locked.c b/src/vcl/vcl_locked.c
index 4b88b27ac6f..678499cd71c 100644
--- a/src/vcl/vcl_locked.c
+++ b/src/vcl/vcl_locked.c
@@ -1491,44 +1491,30 @@ static void
 vls_app_fork_child_handler (void)
 {
   vcl_worker_t *parent_wrk;
-  int rv, parent_wrk_index;
-  u8 *child_name;
+  int parent_wrk_index;
 
   parent_wrk_index = vcl_get_worker_index ();
   VDBG (0, "initializing forked child %u with parent wrk %u", getpid (),
 	parent_wrk_index);
 
   /*
-   * Allocate worker vcl
+   * Clear old state
    */
   vcl_set_worker_index (~0);
-  if (!vcl_worker_alloc_and_init ())
-    VERR ("couldn't allocate new worker");
 
   /*
-   * Attach to binary api
+   * Allocate and register vcl worker with vpp
    */
-  child_name = format (0, "%v-child-%u%c", vcm->app_name, getpid (), 0);
-  vcl_cleanup_bapi ();
-  vppcom_api_hookup ();
-  vcm->app_state = STATE_APP_START;
-  rv = vppcom_connect_to_vpp ((char *) child_name);
-  vec_free (child_name);
-  if (rv)
+  if (vppcom_worker_register ())
     {
-      VERR ("couldn't connect to VPP!");
+      VERR ("couldn't register new worker!");
       return;
     }
 
   /*
-   * Allocate/initialize vls worker
+   * Allocate/initialize vls worker and share sessions
    */
   vls_worker_alloc ();
-
-  /*
-   * Register worker with vpp and share sessions
-   */
-  vcl_worker_register_with_vpp ();
   parent_wrk = vcl_worker_get (parent_wrk_index);
   vls_worker_copy_on_fork (parent_wrk);
   parent_wrk->forked_child = vcl_get_worker_index ();
diff --git a/src/vcl/vcl_private.c b/src/vcl/vcl_private.c
index 1dadb628fb8..a07e0b165ec 100644
--- a/src/vcl/vcl_private.c
+++ b/src/vcl/vcl_private.c
@@ -17,57 +17,6 @@
 
 static pthread_key_t vcl_worker_stop_key;
 
-static const char *
-vppcom_app_state_str (app_state_t state)
-{
-  char *st;
-
-  switch (state)
-    {
-    case STATE_APP_START:
-      st = "STATE_APP_START";
-      break;
-
-    case STATE_APP_CONN_VPP:
-      st = "STATE_APP_CONN_VPP";
-      break;
-
-    case STATE_APP_ENABLED:
-      st = "STATE_APP_ENABLED";
-      break;
-
-    case STATE_APP_ATTACHED:
-      st = "STATE_APP_ATTACHED";
-      break;
-
-    default:
-      st = "UNKNOWN_APP_STATE";
-      break;
-    }
-
-  return st;
-}
-
-int
-vcl_wait_for_app_state_change (app_state_t app_state)
-{
-  vcl_worker_t *wrk = vcl_worker_get_current ();
-  f64 timeout = clib_time_now (&wrk->clib_time) + vcm->cfg.app_timeout;
-
-  while (clib_time_now (&wrk->clib_time) < timeout)
-    {
-      if (vcm->app_state == app_state)
-	return VPPCOM_OK;
-      if (vcm->app_state == STATE_APP_FAILED)
-	return VPPCOM_ECONNABORTED;
-    }
-  VDBG (0, "timeout waiting for state %s (%d)",
-	vppcom_app_state_str (app_state), app_state);
-  vcl_evt (VCL_EVT_SESSION_TIMEOUT, vcm, app_state);
-
-  return VPPCOM_ETIMEDOUT;
-}
-
 vcl_mq_evt_conn_t *
 vcl_mq_evt_conn_alloc (vcl_worker_t * wrk)
 {
@@ -157,19 +106,7 @@ vcl_worker_cleanup (vcl_worker_t * wrk, u8 notify_vpp)
 {
   clib_spinlock_lock (&vcm->workers_lock);
   if (notify_vpp)
-    {
-      /* Notify vpp that the worker is going away */
-      if (wrk->wrk_index == vcl_get_worker_index ())
-	vcl_send_app_worker_add_del (0 /* is_add */ );
-      else
-	vcl_send_child_worker_del (wrk);
-
-      /* Disconnect the binary api */
-      if (vec_len (vcm->workers) == 1)
-	vppcom_disconnect_from_vpp ();
-      else
-	vl_client_send_disconnect (1 /* vpp should cleanup */ );
-    }
+    vcl_bapi_app_worker_del (wrk);
 
   if (wrk->mqs_epfd > 0)
     close (wrk->mqs_epfd);
@@ -247,11 +184,10 @@ vcl_worker_register_with_vpp (void)
 
   clib_spinlock_lock (&vcm->workers_lock);
 
-  vcm->app_state = STATE_APP_ADDING_WORKER;
-  vcl_send_app_worker_add_del (1 /* is_add */ );
-  if (vcl_wait_for_app_state_change (STATE_APP_READY))
+  if (vcl_bapi_app_worker_add ())
     {
       VDBG (0, "failed to add worker to vpp");
+      clib_spinlock_unlock (&vcm->workers_lock);
       return -1;
     }
   if (pthread_key_create (&vcl_worker_stop_key, vcl_worker_cleanup_cb))
@@ -265,48 +201,12 @@ vcl_worker_register_with_vpp (void)
   return 0;
 }
 
-int
-vcl_worker_set_bapi (void)
-{
-  vcl_worker_t *wrk = vcl_worker_get_current ();
-  int i;
-
-  /* Find the first worker with the same pid */
-  for (i = 0; i < vec_len (vcm->workers); i++)
-    {
-      if (i == wrk->wrk_index)
-	continue;
-      if (vcm->workers[i].current_pid == wrk->current_pid)
-	{
-	  wrk->vl_input_queue = vcm->workers[i].vl_input_queue;
-	  wrk->my_client_index = vcm->workers[i].my_client_index;
-	  return 0;
-	}
-    }
-  return -1;
-}
-
 svm_msg_q_t *
 vcl_worker_ctrl_mq (vcl_worker_t * wrk)
 {
   return wrk->ctrl_mq;
 }
 
-void
-vcl_cleanup_bapi (void)
-{
-  socket_client_main_t *scm = &socket_client_main;
-  api_main_t *am = vlibapi_get_main ();
-
-  am->my_client_index = ~0;
-  am->my_registration = 0;
-  am->vl_input_queue = 0;
-  am->msg_index_by_name_and_crc = 0;
-  scm->socket_fd = 0;
-
-  vl_client_api_unmap ();
-}
-
 int
 vcl_session_read_ready (vcl_session_t * session)
 {
diff --git a/src/vcl/vcl_private.h b/src/vcl/vcl_private.h
index c930803f760..7e1d35b2205 100644
--- a/src/vcl/vcl_private.h
+++ b/src/vcl/vcl_private.h
@@ -60,7 +60,7 @@ typedef enum
   STATE_APP_ADDING_TLS_DATA,
   STATE_APP_FAILED,
   STATE_APP_READY
-} app_state_t;
+} vcl_bapi_app_state_t;
 
 typedef enum
 {
@@ -214,9 +214,9 @@ typedef struct vppcom_cfg_t_
   f64 accept_timeout;
   u32 event_ring_size;
   char *event_log_path;
-  u8 *vpp_api_filename;
-  u8 *vpp_api_socket_name;
-  u8 *vpp_api_chroot;
+  u8 *vpp_bapi_filename;	/**< bapi shm transport file name */
+  u8 *vpp_bapi_socket_name;	/**< bapi socket transport socket name */
+  u8 *vpp_bapi_chroot;
   u32 tls_engine;
   u8 mt_wrk_supported;
 } vppcom_cfg_t;
@@ -251,11 +251,8 @@ typedef struct vcl_worker_
   /** Worker index in vpp*/
   u32 vpp_wrk_index;
 
-  /** API client handle */
-  u32 my_client_index;
-
-  /** State of the connection, shared between msg RX thread and main thread */
-  volatile app_state_t wrk_state;
+  /** VPP bapi client handle */
+  u32 bapi_client_index;
 
   /** VPP binary api input queue */
   svm_queue_t *vl_input_queue;
@@ -328,9 +325,6 @@ typedef struct vppcom_main_t_
   /** App's index in vpp. It's used by vpp to identify the app */
   u32 app_index;
 
-  /** State of the connection, shared between msg RX thread and main thread */
-  volatile app_state_t app_state;
-
   u8 *app_name;
 
   /** VCL configuration */
@@ -355,17 +349,24 @@ typedef struct vppcom_main_t_
 
   fifo_segment_main_t segment_main;
 
+  vcl_rpc_fn_t *wrk_rpc_fn;
+
+  /*
+   * Binary api context
+   */
+
+  /* State of the connection, shared between msg RX thread and main thread */
+  volatile vcl_bapi_app_state_t bapi_app_state;
+
+  /* VNET_API_ERROR_FOO -> "Foo" hash table */
+  uword *error_string_by_error_number;
+
 #ifdef VCL_ELOG
   /* VPP Event-logger */
   elog_main_t elog_main;
   elog_track_t elog_track;
 #endif
 
-  /* VNET_API_ERROR_FOO -> "Foo" hash table */
-  uword *error_string_by_error_number;
-
-  vcl_rpc_fn_t *wrk_rpc_fn;
-
 } vppcom_main_t;
 
 extern vppcom_main_t *vcm;
@@ -612,7 +613,6 @@ vcl_proto_is_dgram (uint8_t proto)
 /*
  * Helpers
  */
-int vcl_wait_for_app_state_change (app_state_t app_state);
 vcl_mq_evt_conn_t *vcl_mq_evt_conn_alloc (vcl_worker_t * wrk);
 u32 vcl_mq_evt_conn_index (vcl_worker_t * wrk, vcl_mq_evt_conn_t * mqc);
 vcl_mq_evt_conn_t *vcl_mq_evt_conn_get (vcl_worker_t * wrk, u32 mq_conn_idx);
@@ -622,11 +622,9 @@ int vcl_mq_epoll_del_evfd (vcl_worker_t * wrk, u32 mqc_index);
 vcl_worker_t *vcl_worker_alloc_and_init (void);
 void vcl_worker_cleanup (vcl_worker_t * wrk, u8 notify_vpp);
 int vcl_worker_register_with_vpp (void);
-int vcl_worker_set_bapi (void);
 svm_msg_q_t *vcl_worker_ctrl_mq (vcl_worker_t * wrk);
 
 void vcl_flush_mq_events (void);
-void vcl_cleanup_bapi (void);
 int vcl_session_cleanup (vcl_worker_t * wrk, vcl_session_t * session,
 			 vcl_session_handle_t sh, u8 do_disconnect);
 
@@ -673,32 +671,25 @@ void vcl_send_session_worker_update (vcl_worker_t * wrk, vcl_session_t * s,
 				     u32 wrk_index);
 int vcl_send_worker_rpc (u32 dst_wrk_index, void *data, u32 data_len);
 
-/*
- * VCL Binary API
- */
-int vppcom_connect_to_vpp (const char *app_name);
-void vppcom_disconnect_from_vpp (void);
-void vppcom_init_error_string_table (void);
-void vppcom_send_session_enable_disable (u8 is_enable);
-void vppcom_app_send_attach (void);
-void vppcom_app_send_detach (void);
-void vcl_send_session_unlisten (vcl_worker_t * wrk, vcl_session_t * s);
-void vppcom_send_disconnect_session (u64 vpp_handle);
-void vppcom_api_hookup (void);
-void vppcom_send_application_tls_cert_add (vcl_session_t * session,
-					   char *cert, u32 cert_len);
-void vppcom_send_application_tls_key_add (vcl_session_t * session, char *key,
-					  u32 key_len);
-void vcl_send_app_worker_add_del (u8 is_add);
-void vcl_send_child_worker_del (vcl_worker_t * wrk);
-
 int vcl_segment_attach (u64 segment_handle, char *name,
 			ssvm_segment_type_t type, int fd);
 void vcl_segment_detach (u64 segment_handle);
+void vcl_send_session_unlisten (vcl_worker_t * wrk, vcl_session_t * s);
 
-u32 vcl_max_nsid_len (void);
+/*
+ * VCL Binary API
+ */
+int vcl_bapi_attach (void);
+int vcl_bapi_app_worker_add (void);
+void vcl_bapi_app_worker_del (vcl_worker_t * wrk);
+void vcl_bapi_disconnect_from_vpp (void);
+void vcl_bapi_send_application_tls_cert_add (vcl_session_t * session,
+					     char *cert, u32 cert_len);
+void vcl_bapi_send_application_tls_key_add (vcl_session_t * session,
+					    char *key, u32 key_len);
+u32 vcl_bapi_max_nsid_len (void);
+int vcl_bapi_worker_set (void);
 
-void vls_init ();
 #endif /* SRC_VCL_VCL_PRIVATE_H_ */
 
 /*
diff --git a/src/vcl/vppcom.c b/src/vcl/vppcom.c
index dd8ffb46e1b..0f79f88423f 100644
--- a/src/vcl/vppcom.c
+++ b/src/vcl/vppcom.c
@@ -202,7 +202,7 @@ vcl_send_session_listen (vcl_worker_t * wrk, vcl_session_t * s)
   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_LISTEN);
   mp = (session_listen_msg_t *) app_evt->evt->data;
   memset (mp, 0, sizeof (*mp));
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   mp->context = s->session_index;
   mp->wrk_index = wrk->vpp_wrk_index;
   mp->is_ip4 = s->transport.is_ip4;
@@ -225,7 +225,7 @@ vcl_send_session_connect (vcl_worker_t * wrk, vcl_session_t * s)
   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_CONNECT);
   mp = (session_connect_msg_t *) app_evt->evt->data;
   memset (mp, 0, sizeof (*mp));
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   mp->context = s->session_index;
   mp->wrk_index = wrk->vpp_wrk_index;
   mp->is_ip4 = s->transport.is_ip4;
@@ -251,7 +251,7 @@ vcl_send_session_unlisten (vcl_worker_t * wrk, vcl_session_t * s)
   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_UNLISTEN);
   mp = (session_unlisten_msg_t *) app_evt->evt->data;
   memset (mp, 0, sizeof (*mp));
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   mp->wrk_index = wrk->vpp_wrk_index;
   mp->handle = s->vpp_handle;
   mp->context = wrk->wrk_index;
@@ -270,7 +270,7 @@ vcl_send_session_disconnect (vcl_worker_t * wrk, vcl_session_t * s)
   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_DISCONNECT);
   mp = (session_disconnect_msg_t *) app_evt->evt->data;
   memset (mp, 0, sizeof (*mp));
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   mp->handle = s->vpp_handle;
   app_send_ctrl_evt_to_vpp (mq, app_evt);
 }
@@ -286,7 +286,7 @@ vcl_send_app_detach (vcl_worker_t * wrk)
   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_APP_DETACH);
   mp = (session_app_detach_msg_t *) app_evt->evt->data;
   memset (mp, 0, sizeof (*mp));
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   app_send_ctrl_evt_to_vpp (mq, app_evt);
 }
 
@@ -344,7 +344,7 @@ vcl_send_session_worker_update (vcl_worker_t * wrk, vcl_session_t * s,
   mq = vcl_session_vpp_evt_q (wrk, s);
   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_WORKER_UPDATE);
   mp = (session_worker_update_msg_t *) app_evt->evt->data;
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   mp->handle = s->vpp_handle;
   mp->req_wrk_index = wrk->vpp_wrk_index;
   mp->wrk_index = wrk_index;
@@ -373,7 +373,7 @@ vcl_send_worker_rpc (u32 dst_wrk_index, void *data, u32 data_len)
   mq = vcl_worker_ctrl_mq (wrk);
   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_APP_WRK_RPC);
   mp = (session_app_wrk_rpc_msg_t *) app_evt->evt->data;
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   mp->wrk_index = dst_wrk->vpp_wrk_index;
   clib_memcpy (mp->data, data, data_len);
   app_send_ctrl_evt_to_vpp (mq, app_evt);
@@ -1072,42 +1072,6 @@ vcl_flush_mq_events (void)
 }
 
 static int
-vppcom_app_session_enable (void)
-{
-  int rv;
-
-  if (vcm->app_state != STATE_APP_ENABLED)
-    {
-      vppcom_send_session_enable_disable (1 /* is_enabled == TRUE */ );
-      rv = vcl_wait_for_app_state_change (STATE_APP_ENABLED);
-      if (PREDICT_FALSE (rv))
-	{
-	  VDBG (0, "application session enable timed out! returning %d (%s)",
-		rv, vppcom_retval_str (rv));
-	  return rv;
-	}
-    }
-  return VPPCOM_OK;
-}
-
-static int
-vppcom_app_attach (void)
-{
-  int rv;
-
-  vppcom_app_send_attach ();
-  rv = vcl_wait_for_app_state_change (STATE_APP_ATTACHED);
-  if (PREDICT_FALSE (rv))
-    {
-      VDBG (0, "application attach timed out! returning %d (%s)", rv,
-	    vppcom_retval_str (rv));
-      return rv;
-    }
-
-  return VPPCOM_OK;
-}
-
-static int
 vppcom_session_unbind (u32 session_handle)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
@@ -1171,7 +1135,7 @@ vppcom_session_disconnect (u32 session_handle)
   if (state & STATE_VPP_CLOSING)
     {
       vpp_evt_q = vcl_session_vpp_evt_q (wrk, session);
-      vcl_send_session_disconnected_reply (vpp_evt_q, wrk->my_client_index,
+      vcl_send_session_disconnected_reply (vpp_evt_q, wrk->bapi_client_index,
 					   vpp_handle, 0);
       VDBG (1, "session %u [0x%llx]: sending disconnect REPLY...",
 	    session->session_index, vpp_handle);
@@ -1236,44 +1200,22 @@ vppcom_app_create (const char *app_name)
   vcm->main_cpu = pthread_self ();
   vcm->main_pid = getpid ();
   vcm->app_name = format (0, "%s", app_name);
-  vppcom_init_error_string_table ();
   fifo_segment_main_init (&vcm->segment_main, vcl_cfg->segment_baseva,
 			  20 /* timeout in secs */ );
   pool_alloc (vcm->workers, vcl_cfg->max_workers);
   clib_spinlock_init (&vcm->workers_lock);
   clib_rwlock_init (&vcm->segment_table_lock);
   atexit (vppcom_app_exit);
+  vcl_elog_init (vcm);
 
   /* Allocate default worker */
   vcl_worker_alloc_and_init ();
 
-  /* API hookup and connect to VPP */
-  vcl_elog_init (vcm);
-  vcm->app_state = STATE_APP_START;
-  rv = vppcom_connect_to_vpp (app_name);
-  if (rv)
-    {
-      VERR ("couldn't connect to VPP!");
-      return rv;
-    }
-  VDBG (0, "sending session enable");
-  rv = vppcom_app_session_enable ();
-  if (rv)
-    {
-      VERR ("vppcom_app_session_enable() failed!");
-      return rv;
-    }
-
-  VDBG (0, "sending app attach");
-  rv = vppcom_app_attach ();
-  if (rv)
-    {
-      VERR ("vppcom_app_attach() failed!");
-      return rv;
-    }
+  if ((rv = vcl_bapi_attach ()))
+    return rv;
 
   VDBG (0, "app_name '%s', my_client_index %d (0x%x)", app_name,
-	vcm->workers[0].my_client_index, vcm->workers[0].my_client_index);
+	vcm->workers[0].bapi_client_index, vcm->workers[0].bapi_client_index);
 
   return VPPCOM_OK;
 }
@@ -1300,7 +1242,7 @@ vppcom_app_destroy (void)
   /* *INDENT-ON* */
 
   vcl_send_app_detach (current_wrk);
-  vppcom_disconnect_from_vpp ();
+  vcl_bapi_disconnect_from_vpp ();
   vcl_worker_cleanup (current_wrk, 0 /* notify vpp */ );
 
   vcl_elog_stop (vcm);
@@ -1410,7 +1352,7 @@ vcl_session_cleanup (vcl_worker_t * wrk, vcl_session_t * session,
   else if (state == STATE_DISCONNECT)
     {
       svm_msg_q_t *mq = vcl_session_vpp_evt_q (wrk, session);
-      vcl_send_session_reset_reply (mq, wrk->my_client_index,
+      vcl_send_session_reset_reply (mq, wrk->bapi_client_index,
 				    session->vpp_handle, 0);
     }
   else if (state == STATE_DETACHED)
@@ -1536,52 +1478,6 @@ vppcom_session_listen (uint32_t listen_sh, uint32_t q_len)
   return VPPCOM_OK;
 }
 
-int
-vppcom_session_tls_add_cert (uint32_t session_handle, char *cert,
-			     uint32_t cert_len)
-{
-
-  vcl_worker_t *wrk = vcl_worker_get_current ();
-  vcl_session_t *session = 0;
-
-  session = vcl_session_get_w_handle (wrk, session_handle);
-  if (!session)
-    return VPPCOM_EBADFD;
-
-  if (cert_len == 0 || cert_len == ~0)
-    return VPPCOM_EBADFD;
-
-  /*
-   * Send listen request to vpp and wait for reply
-   */
-  vppcom_send_application_tls_cert_add (session, cert, cert_len);
-  vcm->app_state = STATE_APP_ADDING_TLS_DATA;
-  vcl_wait_for_app_state_change (STATE_APP_READY);
-  return VPPCOM_OK;
-
-}
-
-int
-vppcom_session_tls_add_key (uint32_t session_handle, char *key,
-			    uint32_t key_len)
-{
-
-  vcl_worker_t *wrk = vcl_worker_get_current ();
-  vcl_session_t *session = 0;
-
-  session = vcl_session_get_w_handle (wrk, session_handle);
-  if (!session)
-    return VPPCOM_EBADFD;
-
-  if (key_len == 0 || key_len == ~0)
-    return VPPCOM_EBADFD;
-
-  vppcom_send_application_tls_key_add (session, key, key_len);
-  vcm->app_state = STATE_APP_ADDING_TLS_DATA;
-  vcl_wait_for_app_state_change (STATE_APP_READY);
-  return VPPCOM_OK;
-}
-
 static int
 validate_args_session_accept_ (vcl_worker_t * wrk, vcl_session_t * ls)
 {
@@ -3909,22 +3805,9 @@ vppcom_session_worker (vcl_session_handle_t session_handle)
 int
 vppcom_worker_register (void)
 {
-  vcl_worker_t *wrk;
-  u8 *wrk_name = 0;
-  int rv;
-
   if (!vcl_worker_alloc_and_init ())
     return VPPCOM_EEXIST;
 
-  wrk = vcl_worker_get_current ();
-  wrk_name = format (0, "%s-wrk-%u", vcm->app_name, wrk->wrk_index);
-
-  rv = vppcom_connect_to_vpp ((char *) wrk_name);
-  vec_free (wrk_name);
-
-  if (rv)
-    return VPPCOM_EFAULT;
-
   if (vcl_worker_register_with_vpp ())
     return VPPCOM_EEXIST;