vpp-api: rename libpneum to libvppapiclient

Change-Id: Ie6d2c769b316b43c40632aa9009c4ff6442cf658
Signed-off-by: Damjan Marion <damarion@cisco.com>

8 files changed, 177 insertions, 159 deletions

diff --git a/src/vpp-api.am b/src/vpp-api.am
index 49e26da1460..553eafa83b5 100644
--- a/src/vpp-api.am
+++ b/src/vpp-api.am
@@ -14,29 +14,32 @@
 #
 # VPP API C wrapper extension
 #
-lib_LTLIBRARIES += libpneum.la
-libpneum_la_SOURCES = vpp-api/pneum/pneum.c
-libpneum_la_LIBADD = \
-  $(top_builddir)/libvppinfra.la \
-  $(top_builddir)/libvlibmemoryclient.la \
-  $(top_builddir)/libsvm.la \
+lib_LTLIBRARIES += libvppapiclient.la
+libvppapiclient_la_SOURCES = \
+  vpp-api/client/client.c \
+  vpp-api/client/libvppapiclient.map
+
+libvppapiclient_la_LIBADD = \
   -lpthread -lm -lrt
 
-libpneum_la_LDFLAGS = -module
-libpneum_la_CPPFLAGS =
+libvppapiclient_la_LDFLAGS = \
+  -Wl,-L$(top_builddir)/.libs,--whole-archive,-l:libsvm.a,-l:libvppinfra.a,-l:libvlibmemoryclient.a,--no-whole-archive \
+  -Wl,--version-script=$(srcdir)/vpp-api/client/libvppapiclient.map,-lrt
+
+libvppapiclient_la_DEPENDENCIES = libvppinfra.la libvlibmemoryclient.la libsvm.la
+
+libvppapiclient_la_CPPFLAGS =
 
-nobase_include_HEADERS += vpp-api/pneum/pneum.h
+nobase_include_HEADERS += vpp-api/client/vppapiclient.h
 
 #
 # Test client
 #
 if ENABLE_TESTS
-noinst_PROGRAMS += test_pneum
-test_pneum_SOURCES = vpp-api/pneum/pneum.c vpp-api/pneum/test_pneum.c
-test_pneum_LDADD = \
-  $(top_builddir)/libvppinfra.la \
-  $(top_builddir)/libvlibmemoryclient.la \
-  $(top_builddir)/libsvm.la \
+noinst_PROGRAMS += vac_test
+vac_test_SOURCES = vpp-api/client/test.c
+vac_test_LDADD = \
+  $(builddir)/libvppapiclient.la \
   -lpthread -lm -lrt
 endif
 
diff --git a/src/vpp-api/pneum/pneum.c b/src/vpp-api/client/client.c
index 8b34d3e4801..8bdcda01c4d 100644
--- a/src/vpp-api/pneum/pneum.c
+++ b/src/vpp-api/client/client.c
@@ -31,7 +31,7 @@
 
 #include <vpp/api/vpe_msg_enum.h>
 
-#include "pneum.h"
+#include "vppapiclient.h"
 
 /*
  * Asynchronous mode:
@@ -39,8 +39,8 @@
  * Synchronous mode:
  *  Client calls blocking read().
  *  Clients are expected to collate events on a queue.
- *  pneum_write() -> suspends RX thread
- *  pneum_read() -> resumes RX thread
+ *  vac_write() -> suspends RX thread
+ *  vac_read() -> resumes RX thread
  */
 
 #define vl_typedefs             /* define message structures */
@@ -65,17 +65,17 @@ typedef struct {
   pthread_cond_t timeout_cv;
   pthread_cond_t timeout_cancel_cv;
   pthread_cond_t terminate_cv;
-} pneum_main_t;
+} vac_main_t;
 
-pneum_main_t pneum_main;
-pneum_callback_t pneum_callback;
+vac_main_t vac_main;
+vac_callback_t vac_callback;
 u16 read_timeout = 0;
 bool rx_is_running = false;
 
 static void
 init (void)
 {
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
   memset(pm, 0, sizeof(*pm));
   pthread_mutex_init(&pm->queue_lock, NULL);
   pthread_cond_init(&pm->suspend_cv, NULL);
@@ -89,7 +89,7 @@ init (void)
 static void
 cleanup (void)
 {
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
   pthread_cond_destroy(&pm->suspend_cv);
   pthread_cond_destroy(&pm->resume_cv);
   pthread_cond_destroy(&pm->timeout_cv);
@@ -109,13 +109,13 @@ void vlib_cli_output (struct vlib_main_t * vm, char * fmt, ...)
 }
 
 void
-pneum_free (void * msg)
+vac_free (void * msg)
 {
   vl_msg_api_free (msg);
 }
 
 static void
-pneum_api_handler (void *msg)
+vac_api_handler (void *msg)
 {
   u16 id = ntohs(*((u16 *)msg));
   msgbuf_t *msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data));
@@ -124,16 +124,16 @@ pneum_api_handler (void *msg)
     clib_warning("Message ID %d has wrong length: %d\n", id, l);
 
   /* Call Python callback */
-  ASSERT(pneum_callback);
-  (pneum_callback)(msg, l);
-  pneum_free(msg);
+  ASSERT(vac_callback);
+  (vac_callback)(msg, l);
+  vac_free(msg);
 }
 
 static void *
-pneum_rx_thread_fn (void *arg)
+vac_rx_thread_fn (void *arg)
 {
   unix_shared_memory_queue_t *q;
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
   api_main_t *am = &api_main;
   uword msg;
 
@@ -170,16 +170,16 @@ pneum_rx_thread_fn (void *arg)
 	  break;
 
 	default:
-	  pneum_api_handler((void *)msg);
+	  vac_api_handler((void *)msg);
 	}
       }
 }
 
 static void *
-pneum_timeout_thread_fn (void *arg)
+vac_timeout_thread_fn (void *arg)
 {
   vl_api_memclnt_read_timeout_t *ep;
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
   api_main_t *am = &api_main;
   struct timespec ts;
   struct timeval tv;
@@ -209,10 +209,10 @@ pneum_timeout_thread_fn (void *arg)
 }
 
 void
-pneum_rx_suspend (void)
+vac_rx_suspend (void)
 {
   api_main_t *am = &api_main;
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
   vl_api_memclnt_rx_thread_suspend_t *ep;
 
   if (!pm->rx_thread_handle) return;
@@ -230,9 +230,9 @@ pneum_rx_suspend (void)
 }
 
 void
-pneum_rx_resume (void)
+vac_rx_resume (void)
 {
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
   if (!pm->rx_thread_handle) return;
   pthread_mutex_lock(&pm->queue_lock);
   if (rx_is_running) goto unlock;
@@ -243,25 +243,25 @@ pneum_rx_resume (void)
 }
 
 static uword *
-pneum_msg_table_get_hash (void)
+vac_msg_table_get_hash (void)
 {
   api_main_t *am = &api_main;
   return (am->msg_index_by_name_and_crc);
 }
 
 int
-pneum_msg_table_size(void)
+vac_msg_table_size(void)
 {
   api_main_t *am = &api_main;
   return hash_elts(am->msg_index_by_name_and_crc);
 }
 
 int
-pneum_connect (char * name, char * chroot_prefix, pneum_callback_t cb,
+vac_connect (char * name, char * chroot_prefix, vac_callback_t cb,
                int rx_qlen)
 {
   int rv = 0;
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
 
   init();
   if (chroot_prefix != NULL)
@@ -279,19 +279,19 @@ pneum_connect (char * name, char * chroot_prefix, pneum_callback_t cb,
 
   if (cb) {
     /* Start the rx queue thread */
-    rv = pthread_create(&pm->rx_thread_handle, NULL, pneum_rx_thread_fn, 0);
+    rv = pthread_create(&pm->rx_thread_handle, NULL, vac_rx_thread_fn, 0);
     if (rv) {
       clib_warning("pthread_create returned %d", rv);
       vl_client_api_unmap();
       return (-1);
     }
-    pneum_callback = cb;
+    vac_callback = cb;
     rx_is_running = true;
   }
 
   /* Start read timeout thread */
   rv = pthread_create(&pm->timeout_thread_handle, NULL,
-		      pneum_timeout_thread_fn, 0);
+		      vac_timeout_thread_fn, 0);
   if (rv) {
     clib_warning("pthread_create returned %d", rv);
     vl_client_api_unmap();
@@ -304,10 +304,10 @@ pneum_connect (char * name, char * chroot_prefix, pneum_callback_t cb,
 }
 
 int
-pneum_disconnect (void)
+vac_disconnect (void)
 {
   api_main_t *am = &api_main;
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
 
   if (!pm->connected_to_vlib) return 0;
 
@@ -338,7 +338,7 @@ pneum_disconnect (void)
 
   vl_client_disconnect();
   vl_client_api_unmap();
-  pneum_callback = 0;
+  vac_callback = 0;
 
   cleanup();
 
@@ -348,7 +348,7 @@ pneum_disconnect (void)
 static void
 set_timeout (unsigned short timeout)
 {
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
   pthread_mutex_lock(&pm->timeout_lock);
   read_timeout = timeout;
   pthread_cond_signal(&pm->timeout_cv);
@@ -358,18 +358,18 @@ set_timeout (unsigned short timeout)
 static void
 unset_timeout (void)
 {
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
   pthread_mutex_lock(&pm->timeout_lock);
   pthread_cond_signal(&pm->timeout_cancel_cv);
   pthread_mutex_unlock(&pm->timeout_lock);
 }
 
 int
-pneum_read (char **p, int *l, u16 timeout)
+vac_read (char **p, int *l, u16 timeout)
 {
   unix_shared_memory_queue_t *q;
   api_main_t *am = &api_main;
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
   uword msg;
   msgbuf_t *msgbuf;
 
@@ -419,7 +419,7 @@ pneum_read (char **p, int *l, u16 timeout)
  error:
   vl_msg_api_free((void *) msg);
   /* Client might forget to resume RX thread on failure */
-  pneum_rx_resume ();
+  vac_rx_resume ();
   return -1;
 }
 
@@ -432,47 +432,47 @@ typedef VL_API_PACKED(struct _vl_api_header {
 }) vl_api_header_t;
 
 static unsigned int
-pneum_client_index (void)
+vac_client_index (void)
 {
   return (api_main.my_client_index);
 }
 
 int
-pneum_write (char *p, int l)
+vac_write (char *p, int l)
 {
   int rv = -1;
   api_main_t *am = &api_main;
   vl_api_header_t *mp = vl_msg_api_alloc(l);
   unix_shared_memory_queue_t *q;
-  pneum_main_t *pm = &pneum_main;
+  vac_main_t *pm = &vac_main;
 
   if (!pm->connected_to_vlib) return -1;
   if (!mp) return (-1);
 
   memcpy(mp, p, l);
-  mp->client_index = pneum_client_index();
+  mp->client_index = vac_client_index();
   q = am->shmem_hdr->vl_input_queue;
   rv = unix_shared_memory_queue_add(q, (u8 *)&mp, 0);
   if (rv != 0) {
     clib_warning("vpe_api_write fails: %d\n", rv);
     /* Clear message */
-    pneum_free(mp);
+    vac_free(mp);
   }
   return (rv);
 }
 
 int
-pneum_get_msg_index (unsigned char * name)
+vac_get_msg_index (unsigned char * name)
 {
   return vl_api_get_msg_index (name);
 }
 
 int
-pneum_msg_table_max_index(void)
+vac_msg_table_max_index(void)
 {
   int max = 0;
   hash_pair_t *hp;
-  uword *h = pneum_msg_table_get_hash();
+  uword *h = vac_msg_table_get_hash();
   hash_foreach_pair (hp, h,
   ({
     if (hp->value[0] > max)
@@ -483,7 +483,7 @@ pneum_msg_table_max_index(void)
 }
 
 void
-pneum_set_error_handler (pneum_error_callback_t cb)
+vac_set_error_handler (vac_error_callback_t cb)
 {
   if (cb) clib_error_register_handler (cb, 0);
 }
diff --git a/src/vpp-api/client/libvppapiclient.map b/src/vpp-api/client/libvppapiclient.map
new file mode 100644
index 00000000000..a9d8f7dd704
--- /dev/null
+++ b/src/vpp-api/client/libvppapiclient.map
@@ -0,0 +1,19 @@
+
+VPPAPICLIENT_17.07 {
+	global:
+	vac_read;
+	vac_write;
+	vac_connect;
+	vac_disconnect;
+	vac_set_error_handler;
+	vac_msg_table_max_index;
+	vac_get_msg_index;
+	vac_rx_suspend;
+	vac_rx_resume;
+	vac_free;
+	vac_msg_table_size;
+
+	api_main;
+
+	local: *;
+};
diff --git a/src/vpp-api/pneum/test_pneum.c b/src/vpp-api/client/test.c
index 334e58e9362..020115d90bb 100644
--- a/src/vpp-api/pneum/test_pneum.c
+++ b/src/vpp-api/client/test.c
@@ -1,6 +1,6 @@
 /*
  *------------------------------------------------------------------
- * test_pneum.c
+ * test.c
  * 
  * Copyright (c) 2016 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -33,13 +33,10 @@
 #include <vlib/vlib.h>
 #include <vlib/unix/unix.h>
 #include <vlibapi/api.h>
-#include <vlibmemory/api.h>
-#include <vnet/ip/ip.h>
 
 #include <vpp/api/vpe_msg_enum.h>
 #include <signal.h>
-#include <setjmp.h>
-#include "pneum.h"
+#include "vppapiclient.h"
 
 #define vl_typedefs             /* define message structures */
 #include <vpp/api/vpe_all_api_h.h> 
@@ -66,7 +63,7 @@ volatile u16 result_msg_id;
 
 
 int
-wrap_pneum_callback (char *data, int len)
+wrap_vac_callback (char *data, int len)
 {
   //printf("Callback %d\n", len);
   result_ready = 1;
@@ -80,7 +77,7 @@ int main (int argc, char ** argv)
   vl_api_show_version_t message;
   vl_api_show_version_t *mp;
   int async = 1;
-  int rv = pneum_connect("pneum_client", NULL, NULL, 32 /* rx queue-length*/);
+  int rv = vac_connect("vac_client", NULL, NULL, 32 /* rx queue-length*/);
 
   if (rv != 0) {
     printf("Connect failed: %d\n", rv);
@@ -109,7 +106,7 @@ int main (int argc, char ** argv)
   for (i = 0; i < no_msgs; i++) {
     /* Construct the API message */
     M_NOALLOC(SHOW_VERSION, show_version);
-    pneum_write((char *)mp, sizeof(*mp));
+    vac_write((char *)mp, sizeof(*mp));
 #ifndef __COVERITY__
     /* As given, async is always 1. Shut up Coverity about it */
     if (!async)
@@ -121,7 +118,7 @@ int main (int argc, char ** argv)
     vl_api_control_ping_t *mp;
     mp = &control;
     M_NOALLOC(CONTROL_PING, control_ping);
-    pneum_write((char *)mp, sizeof(*mp));
+    vac_write((char *)mp, sizeof(*mp));
 
     while (result_msg_id != VL_API_CONTROL_PING_REPLY);
   }
@@ -137,7 +134,7 @@ int main (int argc, char ** argv)
   
   printf("Took %lld msec, %lld msgs/msec \n", (timestamp_msec_end - timestamp_msec_start),
 	 no_msgs/(timestamp_msec_end - timestamp_msec_start));
-  fformat(stdout, "Exiting...\n");
-  pneum_disconnect();
+  printf("Exiting...\n");
+  vac_disconnect();
   exit (0);
 }
diff --git a/src/vpp-api/client/vppapiclient.h b/src/vpp-api/client/vppapiclient.h
new file mode 100644
index 00000000000..839ec1f851f
--- /dev/null
+++ b/src/vpp-api/client/vppapiclient.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef included_vppapiclient_h
+#define included_vppapiclient_h
+
+#include <stdint.h>
+
+typedef void (*vac_callback_t)(unsigned char * data, int len);
+typedef void (*vac_error_callback_t)(void *, unsigned char *, int);
+int vac_connect(char * name, char * chroot_prefix, vac_callback_t cb,
+    int rx_qlen);
+int vac_disconnect(void);
+int vac_read(char **data, int *l, unsigned short timeout);
+int vac_write(char *data, int len);
+void vac_free(void * msg);
+
+int vac_get_msg_index(unsigned char * name);
+int vac_msg_table_size(void);
+int vac_msg_table_max_index(void);
+
+void vac_rx_suspend (void);
+void vac_rx_resume (void);
+void vac_set_error_handler(vac_error_callback_t);
+#endif
diff --git a/src/vpp-api/lua/vpp-lapi.lua b/src/vpp-api/lua/vpp-lapi.lua
index ebfd032b096..587eb110da4 100644
--- a/src/vpp-api/lua/vpp-lapi.lua
+++ b/src/vpp-api/lua/vpp-lapi.lua
@@ -420,20 +420,20 @@ end
 
 
 function vpp.init(vpp, args)
-  local pneum_api = args.pneum_api or [[
- int cough_pneum_attach(char *pneum_path, char *cough_path);
- int pneum_connect(char *name, char *chroot_prefix, void *cb);
- int pneum_disconnect(void);
- int pneum_read(char **data, int *l);
- int pneum_write(char *data, int len);
- void pneum_free(char *data);
- uint32_t pneum_get_msg_index(unsigned char * name);
+  local vac_api = args.vac_api or [[
+ int cough_vac_attach(char *vac_path, char *cough_path);
+ int vac_connect(char *name, char *chroot_prefix, void *cb);
+ int vac_disconnect(void);
+ int vac_read(char **data, int *l);
+ int vac_write(char *data, int len);
+ void vac_free(char *data);
+ uint32_t vac_get_msg_index(unsigned char * name);
 ]]
 
-  vpp.pneum_path = args.pneum_path
-  ffi.cdef(pneum_api)
+  vpp.vac_path = args.vac_path
+  ffi.cdef(vac_api)
   local init_res = 0
-  vpp.pneum = ffi.load(vpp.pneum_path)
+  vpp.vac = ffi.load(vpp.vac_path)
   if (init_res < 0) then
     return nil
   end
@@ -676,7 +676,7 @@ end
 
 function vpp.resolve_message_number(msgname)
   local name = msgname .. "_" .. vpp.msg_name_to_crc[msgname]
-  local idx = vpp.pneum.pneum_get_msg_index(vpp.c_str(name))
+  local idx = vpp.vac.vac_get_msg_index(vpp.c_str(name))
   if vpp.debug_dump then
     print("Index for " .. tostring(name) .. " is " .. tostring(idx))
   end
@@ -692,7 +692,7 @@ function vpp.connect(vpp, client_name)
     if client_name then
       name = client_name
     end
-    local ret = vpp.pneum.pneum_connect(vpp.c_str(client_name), nil, nil)
+    local ret = vpp.vac.vac_connect(vpp.c_str(client_name), nil, nil)
     if tonumber(ret) == 0 then
       vpp.is_connected = true
     end
@@ -702,7 +702,7 @@ function vpp.connect(vpp, client_name)
   end
 
 function vpp.disconnect(vpp)
-    vpp.pneum.pneum_disconnect()
+    vpp.vac.vac_disconnect()
   end
 
 function vpp.json_api(vpp, path, plugin_name)
@@ -921,7 +921,7 @@ function vpp.api_write(vpp, api_name, req_table)
       print("Write Message length: " .. tostring(packed_len) .. "\n" .. vpp.hex_dump(ffi.string(ffi.cast('void *', req_store_cache), packed_len)))
     end
 
-    res = vpp.pneum.pneum_write(ffi.cast('void *', req_store_cache), packed_len)
+    res = vpp.vac.vac_write(ffi.cast('void *', req_store_cache), packed_len)
     return res
   end
 
@@ -932,7 +932,7 @@ function vpp.api_read(vpp)
     local rep_type = "vl_api_opaque_message_t"
     local rep = rep_store_cache
     local replen = rep_len_cache
-    res = vpp.pneum.pneum_read(ffi.cast("void *", rep), replen)
+    res = vpp.vac.vac_read(ffi.cast("void *", rep), replen)
     if vpp.debug_dump then
       print("Read Message length: " .. tostring(replen[0]) .. "\n" .. vpp.hex_dump(ffi.string(ffi.cast('void *', rep[0]), replen[0])))
     end
@@ -946,7 +946,7 @@ function vpp.api_read(vpp)
       out["luaapi_message_name"] = reply_msg_name
     end
 
-    vpp.pneum.pneum_free(ffi.cast('void *',rep[0]))
+    vpp.vac.vac_free(ffi.cast('void *',rep[0]))
 
     return reply_msg_name, out
   end
diff --git a/src/vpp-api/pneum/pneum.h b/src/vpp-api/pneum/pneum.h
deleted file mode 100644
index 669298df838..00000000000
--- a/src/vpp-api/pneum/pneum.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef included_pneum_h
-#define included_pneum_h
-
-#include <stdint.h>
-#include <vppinfra/types.h>
-
-typedef void (*pneum_callback_t)(unsigned char * data, int len);
-typedef void (*pneum_error_callback_t)(void *, unsigned char *, int);
-int pneum_connect(char * name, char * chroot_prefix, pneum_callback_t cb,
-    int rx_qlen);
-int pneum_disconnect(void);
-int pneum_read(char **data, int *l, unsigned short timeout);
-int pneum_write(char *data, int len);
-void pneum_free(void * msg);
-
-int pneum_get_msg_index(unsigned char * name);
-int pneum_msg_table_size(void);
-int pneum_msg_table_max_index(void);
-
-void pneum_rx_suspend (void);
-void pneum_rx_resume (void);
-void pneum_set_error_handler(pneum_error_callback_t);
-#endif
diff --git a/src/vpp-api/python/vpp_papi.py b/src/vpp-api/python/vpp_papi.py
index 81f6903be5a..f0d46f05a55 100644
--- a/src/vpp-api/python/vpp_papi.py
+++ b/src/vpp-api/python/vpp_papi.py
@@ -21,26 +21,26 @@ import atexit, Queue
 from cffi import FFI
 ffi = FFI()
 ffi.cdef("""
-typedef void (*pneum_callback_t)(unsigned char * data, int len);
-typedef void (*pneum_error_callback_t)(void *, unsigned char *, int);
-int pneum_connect(char * name, char * chroot_prefix, pneum_callback_t cb,
+typedef void (*vac_callback_t)(unsigned char * data, int len);
+typedef void (*vac_error_callback_t)(void *, unsigned char *, int);
+int vac_connect(char * name, char * chroot_prefix, vac_callback_t cb,
     int rx_qlen);
-int pneum_disconnect(void);
-int pneum_read(char **data, int *l, unsigned short timeout);
-int pneum_write(char *data, int len);
-void pneum_free(void * msg);
-
-int pneum_get_msg_index(unsigned char * name);
-int pneum_msg_table_size(void);
-int pneum_msg_table_max_index(void);
-
-void pneum_rx_suspend (void);
-void pneum_rx_resume (void);
-void pneum_set_error_handler(pneum_error_callback_t);
+int vac_disconnect(void);
+int vac_read(char **data, int *l, unsigned short timeout);
+int vac_write(char *data, int len);
+void vac_free(void * msg);
+
+int vac_get_msg_index(unsigned char * name);
+int vac_msg_table_size(void);
+int vac_msg_table_max_index(void);
+
+void vac_rx_suspend (void);
+void vac_rx_resume (void);
+void vac_set_error_handler(vac_error_callback_t);
  """)
 
 # Barfs on failure, no need to check success.
-vpp_api = ffi.dlopen('libpneum.so')
+vpp_api = ffi.dlopen('libvppapiclient.so')
 
 def vpp_atexit(self):
     """Clean up VPP connection on shutdown."""
@@ -51,13 +51,13 @@ def vpp_atexit(self):
 vpp_object = None
 
 @ffi.callback("void(unsigned char *, int)")
-def pneum_callback_sync(data, len):
+def vac_callback_sync(data, len):
     vpp_object.msg_handler_sync(ffi.buffer(data, len))
 @ffi.callback("void(unsigned char *, int)")
-def pneum_callback_async(data, len):
+def vac_callback_async(data, len):
     vpp_object.msg_handler_async(ffi.buffer(data, len))
 @ffi.callback("void(void *, unsigned char *, int)")
-def pneum_error_handler(arg, msg, msg_len):
+def vac_error_handler(arg, msg, msg_len):
     vpp_object.logger.warning("PNEUM: %s", ffi.string(msg, msg_len))
 
 class Empty(object):
@@ -138,7 +138,7 @@ class VPP():
         atexit.register(vpp_atexit, self)
 
         # Register error handler
-        vpp_api.pneum_set_error_handler(pneum_error_handler)
+        vpp_api.vac_set_error_handler(vac_error_handler)
 
     class ContextId(object):
         """Thread-safe provider of unique context IDs."""
@@ -379,7 +379,7 @@ class VPP():
             if self.messages[name]['typeonly']: continue
             crc = self.messages[name]['crc']
             n = name + '_' + crc[2:]
-            i = vpp_api.pneum_get_msg_index(bytes(n))
+            i = vpp_api.vac_get_msg_index(bytes(n))
             if i > 0:
                 self.id_msgdef[i] = msgdef
                 self.id_names[i] = name
@@ -400,33 +400,33 @@ class VPP():
         """Send a binary-packed message to VPP."""
         if not self.connected:
             raise IOError(1, 'Not connected')
-        return vpp_api.pneum_write(str(buf), len(buf))
+        return vpp_api.vac_write(str(buf), len(buf))
 
     def _read (self):
         if not self.connected:
             raise IOError(1, 'Not connected')
         mem = ffi.new("char **")
         size = ffi.new("int *")
-        rv = vpp_api.pneum_read(mem, size, self.read_timeout)
+        rv = vpp_api.vac_read(mem, size, self.read_timeout)
         if rv:
-            raise IOError(rv, 'pneum_read filed')
+            raise IOError(rv, 'vac_read filed')
         msg = bytes(ffi.buffer(mem[0], size[0]))
-        vpp_api.pneum_free(mem[0])
+        vpp_api.vac_free(mem[0])
         return msg
 
     def connect_internal(self, name, msg_handler, chroot_prefix, rx_qlen, async):
-	rv = vpp_api.pneum_connect(name, chroot_prefix, msg_handler, rx_qlen)
+	rv = vpp_api.vac_connect(name, chroot_prefix, msg_handler, rx_qlen)
         if rv != 0:
             raise IOError(2, 'Connect failed')
         self.connected = True
 
-        self.vpp_dictionary_maxid = vpp_api.pneum_msg_table_max_index()
+        self.vpp_dictionary_maxid = vpp_api.vac_msg_table_max_index()
         self._register_functions(async=async)
 
         # Initialise control ping
         crc = self.messages['control_ping']['crc']
         self.control_ping_index = \
-                                  vpp_api.pneum_get_msg_index(
+                                  vpp_api.vac_get_msg_index(
                                       bytes('control_ping' + '_' + crc[2:]))
         self.control_ping_msgdef = self.messages['control_ping']
 
@@ -440,8 +440,8 @@ class VPP():
         rx_qlen - the length of the VPP message receive queue between
         client and server.
         """
-        msg_handler = pneum_callback_sync if not async \
-                      else pneum_callback_async
+        msg_handler = vac_callback_sync if not async \
+                      else vac_callback_async
         return self.connect_internal(name, msg_handler, chroot_prefix, rx_qlen,
                                      async)
 
@@ -459,7 +459,7 @@ class VPP():
 
     def disconnect(self):
         """Detach from VPP."""
-        rv = vpp_api.pneum_disconnect()
+        rv = vpp_api.vac_disconnect()
         self.connected = False
         return rv
 
@@ -550,7 +550,7 @@ class VPP():
         kwargs['_vl_msg_id'] = i
         b = self.encode(msgdef, kwargs)
 
-        vpp_api.pneum_rx_suspend()
+        vpp_api.vac_rx_suspend()
         self._write(b)
 
         if multipart:
@@ -580,7 +580,7 @@ class VPP():
 
             rl.append(r)
 
-        vpp_api.pneum_rx_resume()
+        vpp_api.vac_rx_resume()
 
         return rl