1 files changed, 67 insertions, 29 deletions

diff --git a/libtransport/src/hicn/transport/core/vpp_forwarder_interface.cc b/libtransport/src/hicn/transport/core/vpp_forwarder_interface.cc
index 3a748c821..0335c3829 100755..100644
--- a/libtransport/src/hicn/transport/core/vpp_forwarder_interface.cc
+++ b/libtransport/src/hicn/transport/core/vpp_forwarder_interface.cc
@@ -19,6 +19,7 @@
 
 #include <hicn/transport/core/hicn_binary_api.h>
 #include <hicn/transport/core/memif_binary_api.h>
+#include <hicn/transport/core/prefix.h>
 #include <hicn/transport/core/vpp_forwarder_interface.h>
 
 typedef enum { MASTER = 0, SLAVE = 1 } memif_role_t;
@@ -42,7 +43,19 @@ VPPForwarderInterface::VPPForwarderInterface(MemifConnector &connector)
       sw_if_index_(~0),
       face_id_(~0) {}
 
-VPPForwarderInterface::~VPPForwarderInterface() {}
+VPPForwarderInterface::~VPPForwarderInterface() {
+  if (sw_if_index_ != uint32_t(~0) && VPPForwarderInterface::memif_api_) {
+    int ret = memif_binary_api_delete_memif(VPPForwarderInterface::memif_api_, sw_if_index_);
+
+    if (ret < 0) {
+      TRANSPORT_LOGE("Error deleting memif with sw idx %u.", sw_if_index_);
+    }
+  }
+
+  if (VPPForwarderInterface::api_) {
+    vpp_binary_api_destroy(VPPForwarderInterface::api_);
+  }
+}
 
 /**
  * @brief Create a memif interface in the local VPP forwarder.
@@ -50,8 +63,13 @@ VPPForwarderInterface::~VPPForwarderInterface() {}
 uint32_t VPPForwarderInterface::getMemifConfiguration() {
   memif_create_params_t input_params = {0};
 
-  memif_id_ =
-      memif_binary_api_get_next_memif_id(VPPForwarderInterface::memif_api_);
+  int ret = memif_binary_api_get_next_memif_id(
+      VPPForwarderInterface::memif_api_, &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;
@@ -63,8 +81,10 @@ uint32_t VPPForwarderInterface::getMemifConfiguration() {
 
   memif_output_params_t output_params = {0};
 
-  if (memif_binary_api_create_memif(VPPForwarderInterface::memif_api_,
-                                    &input_params, &output_params) < 0) {
+  ret = memif_binary_api_create_memif(VPPForwarderInterface::memif_api_,
+                                    &input_params, &output_params);
+
+  if (ret < 0) {
     throw errors::RuntimeException(
         "Error creating memif interface in the local VPP forwarder.");
   }
@@ -75,23 +95,30 @@ uint32_t VPPForwarderInterface::getMemifConfiguration() {
 void VPPForwarderInterface::consumerConnection() {
   hicn_consumer_input_params input = {0};
   hicn_consumer_output_params output;
+  ip_address_t ip4_address;
+  ip_address_t ip6_address;
 
   std::memset(&output, 0, sizeof(hicn_consumer_output_params));
 
+  output.src4 = &ip4_address;
+  output.src6 = &ip6_address;
+
   input.swif = sw_if_index_;
 
-  if (int ret = hicn_binary_api_register_cons_app(
-                    VPPForwarderInterface::hicn_api_, &input, &output) < 0) {
+  int ret = hicn_binary_api_register_cons_app(
+                    VPPForwarderInterface::hicn_api_, &input, &output);
+
+  if (ret < 0) {
     throw errors::RuntimeException(hicn_binary_api_get_error_string(ret));
   }
 
   inet_address_.family = AF_INET;
-  inet_address_.prefix_len = output.src4.prefix_length;
-  std::memcpy(inet_address_.buffer, output.src4.ip4.as_u8, IPV4_ADDR_LEN);
+  inet_address_.prefix_len = output.src4->prefix_len;
+  std::memcpy(inet_address_.buffer, output.src4->buffer, IPV6_ADDR_LEN);
 
   inet6_address_.family = AF_INET6;
-  inet6_address_.prefix_len = output.src6.prefix_length;
-  std::memcpy(inet6_address_.buffer, output.src6.ip6.as_u8, IPV6_ADDR_LEN);
+  inet6_address_.prefix_len = output.src6->prefix_len;
+  std::memcpy(inet6_address_.buffer, output.src6->buffer, IPV6_ADDR_LEN);
 }
 
 void VPPForwarderInterface::producerConnection() {
@@ -127,6 +154,9 @@ void VPPForwarderInterface::connect(bool is_consumer) {
 void VPPForwarderInterface::registerRoute(Prefix &prefix) {
   auto &addr = prefix.toIpAddressStruct();
 
+  // Same ip address for input and outurt params
+  ip_address_t ip_address;
+
   if (face_id_ == uint32_t(~0)) {
     hicn_producer_input_params input;
     std::memset(&input, 0, sizeof(input));
@@ -134,44 +164,52 @@ void VPPForwarderInterface::registerRoute(Prefix &prefix) {
     hicn_producer_output_params output;
     std::memset(&output, 0, sizeof(output));
 
+    input.prefix = &ip_address;
+    output.prod_addr = &ip_address;
+
     // Here we have to ask to the actual connector what is the
     // memif_id, since this function should be called after the
     // memif creation.
     input.swif = sw_if_index_;
-    input.prefix.ip6.as_u64[0] = addr.as_u64[0];
-    input.prefix.ip6.as_u64[1] = addr.as_u64[1];
-    input.prefix.type = addr.family == AF_INET6 ? IP_TYPE_IP6 : IP_TYPE_IP4;
-    input.prefix.prefix_length = addr.prefix_len;
+    input.prefix->as_u64[0] = addr.as_u64[0];
+    input.prefix->as_u64[1] = addr.as_u64[1];
+    input.prefix->family = addr.family == AF_INET6 ? AF_INET6 : AF_INET;
+    input.prefix->prefix_len = addr.prefix_len;
     input.cs_reserved = content_store_reserved_;
 
-    if (int ret = hicn_binary_api_register_prod_app(
-                      VPPForwarderInterface::hicn_api_, &input, &output) < 0) {
+    int ret = hicn_binary_api_register_prod_app(
+                      VPPForwarderInterface::hicn_api_, &input, &output);
+
+    if (ret < 0) {
       throw errors::RuntimeException(hicn_binary_api_get_error_string(ret));
     }
 
     if (addr.family == AF_INET6) {
-      inet6_address_.prefix_len = output.prod_addr.prefix_length;
-      std::memcpy(inet6_address_.buffer, output.prod_addr.ip6.as_u8,
-                  IPV6_ADDR_LEN);
+      inet6_address_.prefix_len = output.prod_addr->prefix_len;
+      inet6_address_.as_u64[0] = output.prod_addr->as_u64[0];
+      inet6_address_.as_u64[1] = output.prod_addr->as_u64[1];
     } else {
-      inet_address_.prefix_len = output.prod_addr.prefix_length;
+      inet_address_.prefix_len = output.prod_addr->prefix_len;
       // The ipv4 is written in the last 4 bytes of the ipv6 address, so we need
       // to copy from the byte 12
-      std::memcpy(inet_address_.buffer, output.prod_addr.ip6.as_u8 + 12,
-                  IPV4_ADDR_LEN);
+      inet_address_.as_u64[0] = output.prod_addr->as_u64[0];
+      inet_address_.as_u64[1] = output.prod_addr->as_u64[1];
     }
 
     face_id_ = output.face_id;
   } else {
     hicn_producer_set_route_params params;
-    params.prefix.ip6.as_u64[0] = addr.as_u64[0];
-    params.prefix.ip6.as_u64[1] = addr.as_u64[1];
-    params.prefix.type = addr.family == AF_INET6 ? IP_TYPE_IP6 : IP_TYPE_IP4;
-    params.prefix.prefix_length = addr.prefix_len;
+    params.prefix = &ip_address;
+    params.prefix->as_u64[0] = addr.as_u64[0];
+    params.prefix->as_u64[1] = addr.as_u64[1];
+    params.prefix->family = addr.family == AF_INET6 ? AF_INET6 : AF_INET;
+    params.prefix->prefix_len = addr.prefix_len;
     params.face_id = face_id_;
 
-    if (int ret = hicn_binary_api_register_route(
-                      VPPForwarderInterface::hicn_api_, &params) < 0) {
+    int ret = hicn_binary_api_register_route(
+                      VPPForwarderInterface::hicn_api_, &params);
+
+    if (ret < 0) {
       throw errors::RuntimeException(hicn_binary_api_get_error_string(ret));
     }
   }