7 files changed, 911 insertions, 0 deletions
diff --git a/libtransport/src/io_modules/memif/CMakeLists.txt b/libtransport/src/io_modules/memif/CMakeLists.txt
new file mode 100644
index 000000000..134ac1db6
--- /dev/null
+++ b/libtransport/src/io_modules/memif/CMakeLists.txt
@@ -0,0 +1,64 @@
+# Copyright (c) 2021-2022 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.
+
+
+##############################################################
+# Dependencies and third party libs
+##############################################################
+find_package(Vpp ${VPP_DEFAULT_VERSION} EXACT REQUIRED)
+
+if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+  find_package(HicnPlugin ${CURRENT_VERSION} REQUIRED)
+  find_package(SafeVapi ${CURRENT_VERSION} REQUIRED)
+else()
+  list(APPEND DEPENDENCIES
+    ${SAFE_VAPI_SHARED}
+  )
+endif()
+
+list(APPEND DEPENDENCIES
+  ${MEMIF_THIRD_PARTY_DEPENDENCIES}
+)
+
+##############################################################
+# Sources
+##############################################################
+list(APPEND MODULE_HEADER_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_vapi.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/memif_connector.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/memif_vapi.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/vpp_forwarder_module.h
+)
+
+list(APPEND MODULE_SOURCE_FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_vapi.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/memif_vapi.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/vpp_forwarder_module.cc
+)
+
+build_module(memif_module
+    SOURCES ${MODULE_SOURCE_FILES}
+    DEPENDS ${DEPENDENCIES}
+    COMPONENT ${LIBTRANSPORT_COMPONENT}-io-modules
+    OBJECT_LIBRARIES ${MEMIF_THIRD_PARTY_OBJECT_LIBRARIES}
+    LINK_LIBRARIES PRIVATE ${HICN_LIBRARIES} ${SAFE_VAPI_LIBRARIES}
+    INCLUDE_DIRS
+      PUBLIC
+        ${MEMIF_THIRD_PARTY_INCLUDE_DIRS}
+        ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS}
+        ${VPP_INCLUDE_DIRS}
+        ${LIBMEMIF_INCLUDE_DIRS}
+        ${SAFE_VAPI_INCLUDE_DIRS}
+    DEFINITIONS ${COMPILER_DEFINITIONS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS} ${MARCH_COMPILER_OPTIONS}
+)
diff --git a/libtransport/src/io_modules/memif/hicn_vapi.c b/libtransport/src/io_modules/memif/hicn_vapi.c
new file mode 100644
index 000000000..9fc64f720
--- /dev/null
+++ b/libtransport/src/io_modules/memif/hicn_vapi.c
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2021 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.
+ */
+
+#include <hicn/transport/config.h>
+#include <io_modules/memif/hicn_vapi.h>
+
+#define HICN_VPP_PLUGIN
+#include <hicn/name.h>
+#undef HICN_VPP_PLUGIN
+
+#include <vapi/hicn.api.vapi.h>
+#include <vapi/ip.api.vapi.h>
+#include <vapi/vapi_safe.h>
+#include <vlib/vlib.h>
+#include <vlibapi/api.h>
+#include <vlibmemory/api.h>
+#include <vnet/ip/format.h>
+#include <vpp_plugins/hicn/error.h>
+#include <vppinfra/error.h>
+
+/////////////////////////////////////////////////////
+const char *HICN_ERROR_STRING[] = {
+#define _(a, b, c) c,
+    foreach_hicn_error
+#undef _
+};
+/////////////////////////////////////////////////////
+
+/*********************** Missing Symbol in vpp libraries
+ * *************************/
+u8 *format_vl_api_address_union(u8 *s, va_list *args) { return NULL; }
+
+/*********************************************************************************/
+
+static vapi_error_e register_prod_app_cb(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_register_prod_app_reply *reply) {
+  hicn_producer_output_params *output_params =
+      (hicn_producer_output_params *)callback_ctx;
+
+  if (reply == NULL) return rv;
+
+  output_params->cs_reserved = reply->cs_reserved;
+  output_params->prod_addr =
+      (hicn_ip_address_t *)malloc(sizeof(hicn_ip_address_t));
+  memset(output_params->prod_addr, 0, sizeof(hicn_ip_address_t));
+  if (reply->prod_addr.af == ADDRESS_IP6)
+    memcpy(&output_params->prod_addr->v6, reply->prod_addr.un.ip6,
+           sizeof(ipv6_address_t));
+  else
+    memcpy(&output_params->prod_addr->v4, reply->prod_addr.un.ip4,
+           sizeof(ipv4_address_t));
+  output_params->face_id = reply->faceid;
+
+  return reply->retval;
+}
+
+int hicn_vapi_register_prod_app(vapi_ctx_t ctx,
+                                hicn_producer_input_params *input_params,
+                                hicn_producer_output_params *output_params) {
+  vapi_lock();
+  vapi_msg_hicn_api_register_prod_app *msg =
+      vapi_alloc_hicn_api_register_prod_app(ctx);
+
+  if (hicn_ip_address_is_v4(
+          (hicn_ip_address_t *)&input_params->prefix->address)) {
+    memcpy(&msg->payload.prefix.address.un.ip4, &input_params->prefix->address,
+           sizeof(ipv4_address_t));
+    msg->payload.prefix.address.af = ADDRESS_IP4;
+  } else {
+    memcpy(&msg->payload.prefix.address.un.ip6, &input_params->prefix->address,
+           sizeof(ipv6_address_t));
+    msg->payload.prefix.address.af = ADDRESS_IP6;
+  }
+  msg->payload.prefix.len = input_params->prefix->len;
+
+  msg->payload.swif = input_params->swif;
+  msg->payload.cs_reserved = input_params->cs_reserved;
+
+  int ret = vapi_hicn_api_register_prod_app(ctx, msg, register_prod_app_cb,
+                                            output_params);
+  vapi_unlock();
+  return ret;
+}
+
+static vapi_error_e face_prod_del_cb(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_face_prod_del_reply *reply) {
+  if (reply == NULL) return rv;
+
+  return reply->retval;
+}
+
+int hicn_vapi_face_prod_del(vapi_ctx_t ctx,
+                            hicn_del_face_app_input_params *input_params) {
+  vapi_lock();
+  vapi_msg_hicn_api_face_prod_del *msg = vapi_alloc_hicn_api_face_prod_del(ctx);
+
+  msg->payload.faceid = input_params->face_id;
+
+  int ret = vapi_hicn_api_face_prod_del(ctx, msg, face_prod_del_cb, NULL);
+  vapi_unlock();
+  return ret;
+}
+
+static vapi_error_e register_cons_app_cb(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_register_cons_app_reply *reply) {
+  hicn_consumer_output_params *output_params =
+      (hicn_consumer_output_params *)callback_ctx;
+
+  if (reply == NULL) return rv;
+
+  output_params->src6 = (hicn_ip_address_t *)malloc(sizeof(hicn_ip_address_t));
+  output_params->src4 = (hicn_ip_address_t *)malloc(sizeof(hicn_ip_address_t));
+  memset(output_params->src6, 0, sizeof(hicn_ip_address_t));
+  memset(output_params->src4, 0, sizeof(hicn_ip_address_t));
+  memcpy(&output_params->src6->v6, &reply->src_addr6.un.ip6,
+         sizeof(ipv6_address_t));
+  memcpy(&output_params->src4->v4, &reply->src_addr4.un.ip4,
+         sizeof(ipv4_address_t));
+
+  output_params->face_id1 = reply->faceid1;
+  output_params->face_id2 = reply->faceid2;
+
+  return reply->retval;
+}
+
+int hicn_vapi_register_cons_app(vapi_ctx_t ctx,
+                                hicn_consumer_input_params *input_params,
+                                hicn_consumer_output_params *output_params) {
+  vapi_lock();
+  vapi_msg_hicn_api_register_cons_app *msg =
+      vapi_alloc_hicn_api_register_cons_app(ctx);
+
+  msg->payload.swif = input_params->swif;
+
+  int ret = vapi_hicn_api_register_cons_app(ctx, msg, register_cons_app_cb,
+                                            output_params);
+  vapi_unlock();
+  return ret;
+}
+
+static vapi_error_e face_cons_del_cb(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_face_cons_del_reply *reply) {
+  if (reply == NULL) return rv;
+
+  return reply->retval;
+}
+
+int hicn_vapi_face_cons_del(vapi_ctx_t ctx,
+                            hicn_del_face_app_input_params *input_params) {
+  vapi_lock();
+  vapi_msg_hicn_api_face_cons_del *msg = vapi_alloc_hicn_api_face_cons_del(ctx);
+
+  msg->payload.faceid = input_params->face_id;
+
+  int ret = vapi_hicn_api_face_cons_del(ctx, msg, face_cons_del_cb, NULL);
+  vapi_unlock();
+  return ret;
+}
+
+static vapi_error_e reigster_route_cb(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_ip_route_add_del_reply *reply) {
+  if (reply == NULL) return rv;
+
+  return reply->retval;
+}
+
+int hicn_vapi_register_route(vapi_ctx_t ctx,
+                             hicn_producer_set_route_params *input_params) {
+  vapi_lock();
+  vapi_msg_ip_route_add_del *msg = vapi_alloc_ip_route_add_del(ctx, 1);
+
+  msg->payload.is_add = 1;
+  if (hicn_ip_address_is_v4((hicn_ip_address_t *)(input_params->prod_addr))) {
+    memcpy(&msg->payload.route.prefix.address.un.ip4,
+           &input_params->prefix->address.v4, sizeof(ipv4_address_t));
+    msg->payload.route.prefix.address.af = ADDRESS_IP4;
+    msg->payload.route.prefix.len = input_params->prefix->len;
+  } else {
+    memcpy(&msg->payload.route.prefix.address.un.ip6,
+           &input_params->prefix->address.v6, sizeof(ipv6_address_t));
+    msg->payload.route.prefix.address.af = ADDRESS_IP6;
+    msg->payload.route.prefix.len = input_params->prefix->len;
+  }
+
+  msg->payload.route.paths[0].sw_if_index = ~0;
+  msg->payload.route.paths[0].table_id = 0;
+  if (hicn_ip_address_is_v4((hicn_ip_address_t *)(input_params->prod_addr))) {
+    memcpy(&(msg->payload.route.paths[0].nh.address.ip4),
+           input_params->prod_addr->v4.as_u8, sizeof(ipv4_address_t));
+    msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP4;
+  } else {
+    memcpy(&(msg->payload.route.paths[0].nh.address.ip6),
+           input_params->prod_addr->v6.as_u8, sizeof(ipv6_address_t));
+    msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP6;
+  }
+
+  msg->payload.route.paths[0].type = FIB_API_PATH_TYPE_NORMAL;
+  msg->payload.route.paths[0].flags = FIB_API_PATH_FLAG_NONE;
+
+  int ret = vapi_ip_route_add_del(ctx, msg, reigster_route_cb, NULL);
+
+  vapi_unlock();
+  return ret;
+}
+
+char *hicn_vapi_get_error_string(int ret_val) {
+  return get_error_string(ret_val);
+}
diff --git a/libtransport/src/io_modules/memif/hicn_vapi.h b/libtransport/src/io_modules/memif/hicn_vapi.h
new file mode 100644
index 000000000..cfdc93fe3
--- /dev/null
+++ b/libtransport/src/io_modules/memif/hicn_vapi.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2021 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.
+ */
+
+#pragma once
+
+#include <hicn/transport/config.h>
+#include <hicn/util/ip_address.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <vapi/vapi.h>
+
+#include "stdint.h"
+
+typedef struct {
+  hicn_ip_prefix_t* prefix;
+  uint32_t swif;
+  uint32_t cs_reserved;
+} hicn_producer_input_params;
+
+typedef struct {
+  uint32_t swif;
+} hicn_consumer_input_params;
+
+typedef struct {
+  uint32_t face_id;
+} hicn_del_face_app_input_params;
+
+typedef struct {
+  uint32_t cs_reserved;
+  hicn_ip_address_t* prod_addr;
+  uint32_t face_id;
+} hicn_producer_output_params;
+
+typedef struct {
+  hicn_ip_address_t* src4;
+  hicn_ip_address_t* src6;
+  uint32_t face_id1;
+  uint32_t face_id2;
+} hicn_consumer_output_params;
+
+typedef struct {
+  hicn_ip_prefix_t* prefix;
+  hicn_ip_address_t* prod_addr;
+} hicn_producer_set_route_params;
+
+int hicn_vapi_register_prod_app(vapi_ctx_t ctx,
+                                hicn_producer_input_params* input_params,
+                                hicn_producer_output_params* output_params);
+
+int hicn_vapi_register_cons_app(vapi_ctx_t ctx,
+                                hicn_consumer_input_params* input_params,
+                                hicn_consumer_output_params* output_params);
+
+int hicn_vapi_register_route(vapi_ctx_t ctx,
+                             hicn_producer_set_route_params* input_params);
+
+int hicn_vapi_face_cons_del(vapi_ctx_t ctx,
+                            hicn_del_face_app_input_params* input_params);
+
+int hicn_vapi_face_prod_del(vapi_ctx_t ctx,
+                            hicn_del_face_app_input_params* input_params);
+
+char* hicn_vapi_get_error_string(int ret_val);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/libtransport/src/io_modules/memif/memif_vapi.c b/libtransport/src/io_modules/memif/memif_vapi.c
new file mode 100644
index 000000000..54e2c3134
--- /dev/null
+++ b/libtransport/src/io_modules/memif/memif_vapi.c
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2021 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.
+ */
+#include <fcntl.h>
+#include <hicn/transport/config.h>
+#include <inttypes.h>
+#include <io_modules/memif/memif_vapi.h>
+#include <semaphore.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <vapi/vapi_safe.h>
+#include <vppinfra/clib.h>
+
+static vapi_error_e memif_details_cb(vapi_ctx_t ctx, void *callback_ctx,
+                                     vapi_error_e rv, bool is_last,
+                                     vapi_payload_memif_details *reply) {
+  uint32_t *last_memif_id = (uint32_t *)callback_ctx;
+  uint32_t current_memif_id = 0;
+  if (reply != NULL) {
+    current_memif_id = reply->id;
+  } else {
+    return rv;
+  }
+
+  if (current_memif_id >= *last_memif_id) {
+    *last_memif_id = current_memif_id + 1;
+  }
+
+  return rv;
+}
+
+int memif_vapi_get_next_memif_id(vapi_ctx_t ctx, uint32_t *memif_id) {
+  vapi_lock();
+  vapi_msg_memif_dump *msg = vapi_alloc_memif_dump(ctx);
+
+  // Initialize memif id to 0
+  *memif_id = 0;
+  int ret = vapi_memif_dump(ctx, msg, memif_details_cb, memif_id);
+  vapi_unlock();
+  return ret;
+}
+
+static vapi_error_e memif_create_cb(vapi_ctx_t ctx, void *callback_ctx,
+                                    vapi_error_e rv, bool is_last,
+                                    vapi_payload_memif_create_reply *reply) {
+  memif_output_params_t *output_params = (memif_output_params_t *)callback_ctx;
+
+  if (reply == NULL) return rv;
+
+  output_params->sw_if_index = reply->sw_if_index;
+
+  return rv;
+}
+
+int memif_vapi_create_memif(vapi_ctx_t ctx, memif_create_params_t *input_params,
+                            memif_output_params_t *output_params) {
+  vapi_lock();
+  vapi_msg_memif_create *msg = vapi_alloc_memif_create(ctx);
+
+  int ret = 0;
+  if (input_params->socket_id == ~0) {
+    // invalid socket-id
+    ret = -1;
+    goto END;
+  }
+
+  if (!is_pow2(input_params->ring_size)) {
+    // ring size must be power of 2
+    ret = -1;
+    goto END;
+  }
+
+  if (input_params->rx_queues > 255 || input_params->rx_queues < 1) {
+    // rx queue must be between 1 - 255
+    ret = -1;
+    goto END;
+  }
+
+  if (input_params->tx_queues > 255 || input_params->tx_queues < 1) {
+    // tx queue must be between 1 - 255
+    ret = -1;
+    goto END;
+  }
+
+  msg->payload.role = input_params->role;
+  msg->payload.mode = input_params->mode;
+  msg->payload.rx_queues = input_params->rx_queues;
+  msg->payload.tx_queues = input_params->tx_queues;
+  msg->payload.id = input_params->id;
+  msg->payload.socket_id = input_params->socket_id;
+  msg->payload.ring_size = input_params->ring_size;
+  msg->payload.buffer_size = input_params->buffer_size;
+
+  ret = vapi_memif_create(ctx, msg, memif_create_cb, output_params);
+END:
+  vapi_unlock();
+  return ret;
+}
+
+static vapi_error_e memif_delete_cb(vapi_ctx_t ctx, void *callback_ctx,
+                                    vapi_error_e rv, bool is_last,
+                                    vapi_payload_memif_delete_reply *reply) {
+  if (reply == NULL) return rv;
+
+  return reply->retval;
+}
+
+int memif_vapi_delete_memif(vapi_ctx_t ctx, uint32_t sw_if_index) {
+  vapi_lock();
+  vapi_msg_memif_delete *msg = vapi_alloc_memif_delete(ctx);
+
+  msg->payload.sw_if_index = sw_if_index;
+
+  int ret = vapi_memif_delete(ctx, msg, memif_delete_cb, NULL);
+  vapi_unlock();
+  return ret;
+}
diff --git a/libtransport/src/io_modules/memif/memif_vapi.h b/libtransport/src/io_modules/memif/memif_vapi.h
new file mode 100644
index 000000000..f5f0639e7
--- /dev/null
+++ b/libtransport/src/io_modules/memif/memif_vapi.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2021 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.
+ */
+
+#pragma once
+
+#include <hicn/transport/config.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <vapi/memif.api.vapi.h>
+
+#include "stdint.h"
+
+typedef struct memif_create_params_s {
+  uint8_t role;
+  uint8_t mode;
+  uint8_t rx_queues;
+  uint8_t tx_queues;
+  uint32_t id;
+  uint32_t socket_id;
+  uint8_t secret[24];
+  uint32_t ring_size;
+  uint16_t buffer_size;
+  uint8_t hw_addr[6];
+} memif_create_params_t;
+
+typedef struct memif_output_params_s {
+  uint32_t sw_if_index;
+} memif_output_params_t;
+
+int memif_vapi_get_next_memif_id(vapi_ctx_t ctx, uint32_t *memif_id);
+
+int memif_vapi_create_socket(vapi_ctx_t ctx,
+                             memif_create_params_t *input_params,
+                             memif_output_params_t *output_params);
+
+int memif_vapi_create_memif(vapi_ctx_t ctx, memif_create_params_t *input_params,
+                            memif_output_params_t *output_params);
+
+int memif_vapi_delete_memif(vapi_ctx_t ctx, uint32_t sw_if_index);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/libtransport/src/io_modules/memif/vpp_forwarder_module.cc b/libtransport/src/io_modules/memif/vpp_forwarder_module.cc
new file mode 100644
index 000000000..d04c60893
--- /dev/null
+++ b/libtransport/src/io_modules/memif/vpp_forwarder_module.cc
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2021-2023 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.
+ */
+
+#include <core/memif_connector.h>
+#include <glog/logging.h>
+#include <hicn/transport/config.h>
+#include <hicn/transport/errors/not_implemented_exception.h>
+#include <io_modules/memif/hicn_vapi.h>
+#include <io_modules/memif/memif_vapi.h>
+#include <io_modules/memif/vpp_forwarder_module.h>
+
+extern "C" {
+#include <libmemif.h>
+};
+
+typedef enum { MASTER = 0, SLAVE = 1 } memif_role_t;
+
+#define MEMIF_DEFAULT_RING_SIZE 2048
+#define MEMIF_DEFAULT_RX_QUEUES 1
+#define MEMIF_DEFAULT_TX_QUEUES 1
+#define MEMIF_DEFAULT_BUFFER_SIZE 2048
+
+namespace transport {
+
+namespace core {
+
+VPPForwarderModule::VPPForwarderModule()
+    : IoModule(),
+      connector_(nullptr),
+      memif_id_(0),
+      sw_if_index_(~0),
+      face_id1_(~0),
+      face_id2_(~0),
+      is_consumer_(false) {}
+
+VPPForwarderModule::~VPPForwarderModule() {}
+
+void VPPForwarderModule::init(
+    Connector::PacketReceivedCallback &&receive_callback,
+    Connector::PacketSentCallback &&sent_callback,
+    Connector::OnCloseCallback &&close_callback,
+    Connector::OnReconnectCallback &&reconnect_callback,
+    asio::io_service &io_service, const std::string &app_name) {
+  if (!connector_) {
+    connector_ = std::make_unique<MemifConnector>(
+        std::move(receive_callback), std::move(sent_callback),
+        std::move(close_callback), std::move(reconnect_callback), io_service,
+        app_name);
+  }
+}
+
+void VPPForwarderModule::processControlMessageReply(
+    utils::MemBuf &packet_buffer) {
+  throw errors::NotImplementedException();
+}
+
+bool VPPForwarderModule::isControlMessage(utils::MemBuf &packet_buffer) {
+  return false;
+}
+
+bool VPPForwarderModule::isConnected() { return connector_->isConnected(); };
+
+void VPPForwarderModule::send(Packet &packet) {
+  IoModule::send(packet);
+  connector_->send(packet);
+}
+
+void VPPForwarderModule::send(const utils::MemBuf::Ptr &buffer) {
+  counters_.tx_packets++;
+  counters_.tx_bytes += buffer->length();
+
+  // Perfect forwarding
+  connector_->send(buffer);
+}
+
+std::uint32_t VPPForwarderModule::getMtu() { return interface_mtu; }
+
+/**
+ * @brief Create a memif interface in the local VPP forwarder.
+ */
+uint32_t VPPForwarderModule::getMemifConfiguration() {
+  memif_create_params_t input_params = {0};
+
+  int ret = memif_vapi_get_next_memif_id(VPPForwarderModule::sock_, &memif_id_);
+
+  if (ret < 0) {
+    throw errors::RuntimeException(
+        "Error getting next memif id. Could not create memif interface.");
+  }
+
+  input_params.id = memif_id_;
+  input_params.role = memif_role_t::MASTER;
+  input_params.mode = memif_interface_mode_t::MEMIF_INTERFACE_MODE_IP;
+  input_params.rx_queues = MEMIF_DEFAULT_RX_QUEUES;
+  input_params.tx_queues = MEMIF_DEFAULT_TX_QUEUES;
+  input_params.ring_size = MEMIF_DEFAULT_RING_SIZE;
+  input_params.buffer_size = MEMIF_DEFAULT_BUFFER_SIZE;
+
+  memif_output_params_t output_params = {0};
+
+  ret = memif_vapi_create_memif(VPPForwarderModule::sock_, &input_params,
+                                &output_params);
+
+  if (ret < 0) {
+    throw errors::RuntimeException(
+        "Error creating memif interface in the local VPP forwarder.");
+  }
+
+  return output_params.sw_if_index;
+}
+
+void VPPForwarderModule::consumerConnection() {
+  hicn_consumer_input_params input = {0};
+  hicn_consumer_output_params output = {0};
+  hicn_ip_address_t ip4_address;
+  hicn_ip_address_t ip6_address;
+
+  output.src4 = &ip4_address;
+  output.src6 = &ip6_address;
+  input.swif = sw_if_index_;
+
+  int ret =
+      hicn_vapi_register_cons_app(VPPForwarderModule::sock_, &input, &output);
+
+  if (ret < 0) {
+    throw errors::RuntimeException(hicn_vapi_get_error_string(ret));
+  }
+
+  face_id1_ = output.face_id1;
+  face_id2_ = output.face_id2;
+
+  std::memcpy(inet_address_.v4.as_u8, output.src4->v4.as_u8, IPV4_ADDR_LEN);
+
+  std::memcpy(inet6_address_.v6.as_u8, output.src6->v6.as_u8, IPV6_ADDR_LEN);
+}
+
+void VPPForwarderModule::producerConnection() {
+  // Producer connection will be set when we set the first route.
+}
+
+void VPPForwarderModule::connect(bool is_consumer) {
+  int retry = 20;
+
+  LOG(INFO) << "Connecting to VPP through vapi.";
+  vapi_error_e ret = vapi_connect_safe(&sock_, 0);
+
+  while (ret != VAPI_OK && retry > 0) {
+    LOG(ERROR) << "Error connecting to VPP through vapi (error:  " << ret
+               << "). Retrying..";
+    --retry;
+    ret = vapi_connect_safe(&sock_, 0);
+  }
+
+  CHECK_EQ(ret, VAPI_OK)
+      << "Impossible to connect to forwarder. Is VPP running?";
+
+  LOG(INFO) << "Connected to VPP through vapi.";
+
+  sw_if_index_ = getMemifConfiguration();
+
+  is_consumer_ = is_consumer;
+  if (is_consumer_) {
+    consumerConnection();
+  }
+
+  connector_->connect(memif_id_, 0 /* is_master = false */,
+                      memif_socket_filename);
+  connector_->setRole(is_consumer_ ? Connector::Role::CONSUMER
+                                   : Connector::Role::PRODUCER);
+}
+
+void VPPForwarderModule::registerRoute(const Prefix &prefix) {
+  const hicn_ip_prefix_t &addr = prefix.toIpPrefixStruct();
+
+  hicn_ip_prefix_t producer_prefix;
+  hicn_ip_address_t producer_locator;
+
+  if (face_id1_ == uint32_t(~0)) {
+    hicn_producer_input_params input;
+    std::memset(&input, 0, sizeof(input));
+
+    hicn_producer_output_params output;
+    std::memset(&output, 0, sizeof(output));
+
+    input.prefix = &producer_prefix;
+    output.prod_addr = &producer_locator;
+
+    // Here we have to ask to the actual connector what is the
+    // memif_id, since this function should be called after the
+    // memif creation.n
+    input.swif = sw_if_index_;
+    input.prefix->address = addr.address;
+    input.prefix->family = addr.family;
+    input.prefix->len = addr.len;
+    input.cs_reserved = content_store_reserved_;
+
+    int ret =
+        hicn_vapi_register_prod_app(VPPForwarderModule::sock_, &input, &output);
+
+    if (ret < 0) {
+      throw errors::RuntimeException(hicn_vapi_get_error_string(ret));
+    }
+
+    std::memcpy(inet6_address_.v6.as_u8, output.prod_addr->v6.as_u8,
+                sizeof(inet6_address_));
+
+    face_id1_ = output.face_id;
+  } else {
+    hicn_producer_set_route_params params;
+    params.prefix = &producer_prefix;
+    params.prefix->address = addr.address;
+    params.prefix->family = addr.family;
+    params.prefix->len = addr.len;
+    params.prod_addr = &producer_locator;
+
+    int ret = hicn_vapi_register_route(VPPForwarderModule::sock_, &params);
+
+    if (ret < 0) {
+      throw errors::RuntimeException(hicn_vapi_get_error_string(ret));
+    }
+  }
+}
+
+void VPPForwarderModule::closeConnection() {
+  if (VPPForwarderModule::sock_) {
+    if (is_consumer_) {
+      hicn_del_face_app_input_params params;
+      params.face_id = face_id1_;
+      hicn_vapi_face_cons_del(VPPForwarderModule::sock_, &params);
+      params.face_id = face_id2_;
+      hicn_vapi_face_cons_del(VPPForwarderModule::sock_, &params);
+    } else {
+      hicn_del_face_app_input_params params;
+      params.face_id = face_id1_;
+      hicn_vapi_face_prod_del(VPPForwarderModule::sock_, &params);
+    }
+
+    connector_->close();
+
+    if (sw_if_index_ != uint32_t(~0)) {
+      int ret =
+          memif_vapi_delete_memif(VPPForwarderModule::sock_, sw_if_index_);
+      if (ret < 0) {
+        LOG(ERROR) << "Error deleting memif with sw idx " << sw_if_index_;
+      }
+    }
+    vapi_disconnect_safe();
+    VPPForwarderModule::sock_ = nullptr;
+  }
+}
+
+extern "C" IoModule *create_module(void) { return new VPPForwarderModule(); }
+
+}  // namespace core
+
+}  // namespace transport
diff --git a/libtransport/src/io_modules/memif/vpp_forwarder_module.h b/libtransport/src/io_modules/memif/vpp_forwarder_module.h
new file mode 100644
index 000000000..5a5358078
--- /dev/null
+++ b/libtransport/src/io_modules/memif/vpp_forwarder_module.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2021 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.
+ */
+
+#pragma once
+
+#include <hicn/transport/core/io_module.h>
+#include <hicn/transport/core/prefix.h>
+
+#ifdef always_inline
+#undef always_inline
+#endif
+extern "C" {
+#include <vapi/vapi_safe.h>
+};
+
+namespace transport {
+
+namespace core {
+
+class MemifConnector;
+
+class VPPForwarderModule : public IoModule {
+  static inline std::uint16_t interface_mtu = 1500;
+  static inline std::string const memif_socket_filename = "/run/vpp/memif.sock";
+
+ public:
+  VPPForwarderModule();
+  ~VPPForwarderModule();
+
+  void connect(bool is_consumer) override;
+
+  void send(Packet &packet) override;
+  void send(const utils::MemBuf::Ptr &buffer) override;
+
+  bool isConnected() override;
+
+  void init(Connector::PacketReceivedCallback &&receive_callback,
+            Connector::PacketSentCallback &&sent_callback,
+            Connector::OnCloseCallback &&close_callback,
+            Connector::OnReconnectCallback &&reconnect_callback,
+            asio::io_service &io_service,
+            const std::string &app_name = "Libtransport") override;
+
+  void registerRoute(const Prefix &prefix) override;
+
+  std::uint32_t getMtu() override;
+
+  bool isControlMessage(utils::MemBuf &packet_buffer) override;
+
+  void processControlMessageReply(utils::MemBuf &packet_buffer) override;
+
+  void closeConnection() override;
+
+ private:
+  uint32_t getMemifConfiguration();
+  void consumerConnection();
+  void producerConnection();
+
+ private:
+  std::shared_ptr<MemifConnector> connector_;
+  uint32_t memif_id_;
+  uint32_t sw_if_index_;
+  // A consumer socket in vpp has two faces (ipv4 and ipv6)
+  uint32_t face_id1_;
+  uint32_t face_id2_;
+  bool is_consumer_;
+  vapi_ctx_t sock_;
+};
+
+extern "C" IoModule *create_module(void);
+
+}  // namespace core
+
+}  // namespace transport