feat: Due to the deep modifications related to names and packet format,

this task cover a large part of the codebase and involves several changes:

- the library provides a name data structure (hicn_name_t ), which is composed
  of a name prefix (hicn_name_prefix_t) and a name suffix (hicn_name_suffix_t),
  and it has been extended to provide all support functions required for name
  manipulation, including common prefix computation, as required for the Longest
  Prefix Match (LPM)in the forwarder, in addition to Exact Prefix Match (EPM).
- all code has been rewritten to use this data structure instead of having for
  instance the forwarder define its own name class (used to be Name and NameBitVector)
  the code has been refactored to minimize name allocations and copies, one remaining
  aspect is the difference of name storage between PIT and CS entries (respectively
  in the PIT entry, and in the message buffer), which causes the packet cache
  index to be updated when a PIT entry is converted into a CS entry. By storing
  the name in the PIT/CS entry everytime, we might save on this operation).
- hicn-light FIB has been rewritten : code has been refactored and should now be
  shorter and documented; unit tests have been drafted but more would be required
  to cover all cases and match the algorithms to add/remove nodes, as specified in the doc.
  all protocol details and hICN header formats are now abstracted by the library
  for the forwarder (and thus header.h and  protocols/*.h have been removed from
  public includes, and replaced by packet.h providing protocol agnostic packet
  level functions, completely replacing the compat.h header that used to provide
  similar functions.
- this works by exposing a opaque buffer to the application (a kind of socket buffer)
  which is used by the lib to cache the packet format and offsets of the different
  layers in the buffer and provider efficient operations (the packet format is
  either defined for packet construction, or guessed at ingress, and this structure
  is updated accordingly only once).

Co-authored-by: Jordan Augé <jordan.auge+fdio@cisco.com>
Signed-off-by: Luca Muscariello <muscariello@ieee.org>
Change-Id: I31e321897f85f0267fe8ba4720363c180564492f

1 files changed, 406 insertions, 408 deletions

diff --git a/ctrl/facemgr/src/interfaces/network_framework/network_framework.c b/ctrl/facemgr/src/interfaces/network_framework/network_framework.c
index e1f5575d3..7f4a26c56 100644
--- a/ctrl/facemgr/src/interfaces/network_framework/network_framework.c
+++ b/ctrl/facemgr/src/interfaces/network_framework/network_framework.c
@@ -173,501 +173,499 @@ void dump_endpoint(nw_endpoint_t endpoint, int indent) {
   }
 }
 
-  void dump_path(nw_path_t path, int indent) {
-    /* nw_path_enumerate_interfaces : not interesting */
-    nw_path_status_t path_status = nw_path_get_status(path);
-    printfi(indent, "Status: %s\n", path_status_str[path_status]);
-    printfi(indent, "Expensive: %s\n",
-            nw_path_is_expensive(path) ? "true" : "false");
-    printfi(indent, "IPv4 enabled: %s\n",
-            nw_path_has_ipv4(path) ? "true" : "false");
-    printfi(indent, "IPv6 enabled: %s\n",
-            nw_path_has_ipv6(path) ? "true" : "false");
-    printfi(indent, "DNS: %s\n", nw_path_has_dns(path) ? "true" : "false");
-    printfi(indent, "Interfaces:\n");
-    nw_path_enumerate_interfaces(
-        path,
-        (nw_path_enumerate_interfaces_block_t) ^ (nw_interface_t interface) {
-          dump_interface(interface, indent + 1);
-          return true;
-        });
-
-    nw_endpoint_t local = nw_path_copy_effective_local_endpoint(path);
-    printfi(indent, "Effective local endpoint:\n");
-    dump_endpoint(local, indent + 1);
-    nw_release(local);
-
-    nw_endpoint_t remote = nw_path_copy_effective_remote_endpoint(path);
-    printfi(indent, "Effective remote endpoint:\n");
-    dump_endpoint(remote, indent + 1);
-    nw_release(remote);
-  }
+void dump_path(nw_path_t path, int indent) {
+  /* nw_path_enumerate_interfaces : not interesting */
+  nw_path_status_t path_status = nw_path_get_status(path);
+  printfi(indent, "Status: %s\n", path_status_str[path_status]);
+  printfi(indent, "Expensive: %s\n",
+          nw_path_is_expensive(path) ? "true" : "false");
+  printfi(indent, "IPv4 enabled: %s\n",
+          nw_path_has_ipv4(path) ? "true" : "false");
+  printfi(indent, "IPv6 enabled: %s\n",
+          nw_path_has_ipv6(path) ? "true" : "false");
+  printfi(indent, "DNS: %s\n", nw_path_has_dns(path) ? "true" : "false");
+  printfi(indent, "Interfaces:\n");
+  nw_path_enumerate_interfaces(
+      path,
+      (nw_path_enumerate_interfaces_block_t) ^ (nw_interface_t interface) {
+        dump_interface(interface, indent + 1);
+        return true;
+      });
 
-  void dump_connection(nw_connection_t connection, int indent) {
-    nw_endpoint_t remote = nw_connection_copy_endpoint(connection);
-    nw_path_t path = nw_connection_copy_current_path(connection);
+  nw_endpoint_t local = nw_path_copy_effective_local_endpoint(path);
+  printfi(indent, "Effective local endpoint:\n");
+  dump_endpoint(local, indent + 1);
+  nw_release(local);
 
-    printfi(indent, "Remote endpoint:\n");
-    dump_endpoint(remote, indent + 1);
-    printfi(indent, "Path:\n");
-    dump_path(path, indent + 1);
+  nw_endpoint_t remote = nw_path_copy_effective_remote_endpoint(path);
+  printfi(indent, "Effective remote endpoint:\n");
+  dump_endpoint(remote, indent + 1);
+  nw_release(remote);
+}
 
-    /*
-    nw_connection_copy_protocol_metadata();
-    nw_connection_get_maximum_datagram_size();
-    */
+void dump_connection(nw_connection_t connection, int indent) {
+  nw_endpoint_t remote = nw_connection_copy_endpoint(connection);
+  nw_path_t path = nw_connection_copy_current_path(connection);
 
-    nw_release(remote);
-    nw_release(path);
-  }
+  printfi(indent, "Remote endpoint:\n");
+  dump_endpoint(remote, indent + 1);
+  printfi(indent, "Path:\n");
+  dump_path(path, indent + 1);
+
+  /*
+  nw_connection_copy_protocol_metadata();
+  nw_connection_get_maximum_datagram_size();
+  */
+
+  nw_release(remote);
+  nw_release(path);
+}
 
 #if defined(MAC_OS_X_VERSION_10_15)
-  void dump_browse_result(nw_browse_result_t result, int indent) {
-    /* Endpoint */
-    nw_endpoint_t browse_endpoint = nw_browse_result_copy_endpoint(result);
-    if (!browse_endpoint) {
-      ERROR(
-          "[network_framework.dump_result] Failed to retrieve endpoint from "
-          "Bonjour browse result");
-      return;
-    }
-    printfi(indent + 1, "Endpoint:");
-    dump_endpoint(browse_endpoint, indent + 2);
-
-    /* Interfaces */
-    printfi(indent + 1, "Interfaces:");
-    nw_browse_result_enumerate_interfaces(
-        result,
-        (nw_browse_result_enumerate_interface_t) ^ (nw_interface_t interface) {
-          dump_interface(interface, indent + 2);
-          return true;
-        });
+void dump_browse_result(nw_browse_result_t result, int indent) {
+  /* Endpoint */
+  nw_endpoint_t browse_endpoint = nw_browse_result_copy_endpoint(result);
+  if (!browse_endpoint) {
+    ERROR(
+        "[network_framework.dump_result] Failed to retrieve endpoint from "
+        "Bonjour browse result");
+    return;
   }
+  printfi(indent + 1, "Endpoint:");
+  dump_endpoint(browse_endpoint, indent + 2);
+
+  /* Interfaces */
+  printfi(indent + 1, "Interfaces:");
+  nw_browse_result_enumerate_interfaces(
+      result,
+      (nw_browse_result_enumerate_interface_t) ^ (nw_interface_t interface) {
+        dump_interface(interface, indent + 2);
+        return true;
+      });
+}
 #endif /* defined(MAC_OS_X_VERSION_10_15) */
 
-  facelet_t *facelet_create_from_connection(nw_connection_t connection) {
-    facelet_t *facelet;
-    ip_address_t local_addr, remote_addr;
-    uint16_t remote_port;
-
-    nw_path_t path = nw_connection_copy_current_path(connection);
-    nw_endpoint_t local = nw_path_copy_effective_local_endpoint(path);
-    nw_endpoint_t remote = nw_path_copy_effective_remote_endpoint(path);
-    __block nw_interface_t interface;
-
-    const struct sockaddr *local_sa = nw_endpoint_get_address(local);
-    const struct sockaddr *remote_sa = nw_endpoint_get_address(remote);
-
-    assert(local_sa->sa_family == remote_sa->sa_family);
-    switch (local_sa->sa_family) {
-      case AF_INET:
-        local_addr.v4.as_inaddr = ((struct sockaddr_in *)local_sa)->sin_addr;
-        remote_addr.v4.as_inaddr = ((struct sockaddr_in *)remote_sa)->sin_addr;
-        remote_port = ((struct sockaddr_in *)remote_sa)->sin_port;
-        break;
-      case AF_INET6:
-        local_addr.v6.as_in6addr = ((struct sockaddr_in6 *)local_sa)->sin6_addr;
-        remote_addr.v6.as_in6addr =
-            ((struct sockaddr_in6 *)remote_sa)->sin6_addr;
-        remote_port = ((struct sockaddr_in6 *)remote_sa)->sin6_port;
-        break;
-      default:
-        ERROR("Unsupported address family: %d\n", local_sa->sa_family);
-        return NULL;
-    }
-
-    /* Retrieving path interface type (a single one expected */
-    nw_path_enumerate_interfaces(
-        path, (nw_path_enumerate_interfaces_block_t) ^
-                  (nw_interface_t path_interface) {
-                    interface = path_interface;
-                    return false;
-                  });
-
-    const char *name = nw_interface_get_name(interface);
-    netdevice_t netdevice;
-    snprintf(netdevice.name, IFNAMSIZ, "%s", name);
-    netdevice_update_index(&netdevice);
-
-    netdevice_type_t netdevice_type;
-    nw_interface_type_t type = nw_interface_get_type(interface);
-
-    switch (type) {
-      case INTERFACE_TYPE_OTHER:
-        netdevice_type = NETDEVICE_TYPE_UNDEFINED;
-        break;
-      case INTERFACE_TYPE_WIFI:
-        netdevice_type = NETDEVICE_TYPE_WIFI;
-        break;
-      case INTERFACE_TYPE_CELLULAR:
-        netdevice_type = NETDEVICE_TYPE_CELLULAR;
-        break;
-      case INTERFACE_TYPE_WIRED:
-        netdevice_type = NETDEVICE_TYPE_WIRED;
-        break;
-      case INTERFACE_TYPE_LOOPBACK:
-        netdevice_type = NETDEVICE_TYPE_LOOPBACK;
-        break;
-      default:
-        break;
-    }
+facelet_t *facelet_create_from_connection(nw_connection_t connection) {
+  facelet_t *facelet;
+  hicn_ip_address_t local_addr, remote_addr;
+  uint16_t remote_port;
+
+  nw_path_t path = nw_connection_copy_current_path(connection);
+  nw_endpoint_t local = nw_path_copy_effective_local_endpoint(path);
+  nw_endpoint_t remote = nw_path_copy_effective_remote_endpoint(path);
+  __block nw_interface_t interface;
+
+  const struct sockaddr *local_sa = nw_endpoint_get_address(local);
+  const struct sockaddr *remote_sa = nw_endpoint_get_address(remote);
+
+  assert(local_sa->sa_family == remote_sa->sa_family);
+  switch (local_sa->sa_family) {
+    case AF_INET:
+      local_addr.v4.as_inaddr = ((struct sockaddr_in *)local_sa)->sin_addr;
+      remote_addr.v4.as_inaddr = ((struct sockaddr_in *)remote_sa)->sin_addr;
+      remote_port = ((struct sockaddr_in *)remote_sa)->sin_port;
+      break;
+    case AF_INET6:
+      local_addr.v6.as_in6addr = ((struct sockaddr_in6 *)local_sa)->sin6_addr;
+      remote_addr.v6.as_in6addr = ((struct sockaddr_in6 *)remote_sa)->sin6_addr;
+      remote_port = ((struct sockaddr_in6 *)remote_sa)->sin6_port;
+      break;
+    default:
+      ERROR("Unsupported address family: %d\n", local_sa->sa_family);
+      return NULL;
+  }
 
-    nw_release(local);
-    nw_release(remote);
-    nw_release(path);
+  /* Retrieving path interface type (a single one expected */
+  nw_path_enumerate_interfaces(
+      path,
+      (nw_path_enumerate_interfaces_block_t) ^ (nw_interface_t path_interface) {
+        interface = path_interface;
+        return false;
+      });
 
-    facelet = facelet_create();
-    if (!facelet) return NULL;
+  const char *name = nw_interface_get_name(interface);
+  netdevice_t netdevice;
+  snprintf(netdevice.name, IFNAMSIZ, "%s", name);
+  netdevice_update_index(&netdevice);
 
-    facelet_set_netdevice(facelet, netdevice);
-    facelet_set_netdevice_type(facelet, netdevice_type);
-    facelet_set_family(facelet, local_sa->sa_family);
-    facelet_set_local_addr(facelet, local_addr);
-    facelet_set_remote_addr(facelet, remote_addr);
-    facelet_set_remote_port(facelet, remote_port);
+  netdevice_type_t netdevice_type;
+  nw_interface_type_t type = nw_interface_get_type(interface);
 
-    return facelet;
+  switch (type) {
+    case INTERFACE_TYPE_OTHER:
+      netdevice_type = NETDEVICE_TYPE_UNDEFINED;
+      break;
+    case INTERFACE_TYPE_WIFI:
+      netdevice_type = NETDEVICE_TYPE_WIFI;
+      break;
+    case INTERFACE_TYPE_CELLULAR:
+      netdevice_type = NETDEVICE_TYPE_CELLULAR;
+      break;
+    case INTERFACE_TYPE_WIRED:
+      netdevice_type = NETDEVICE_TYPE_WIRED;
+      break;
+    case INTERFACE_TYPE_LOOPBACK:
+      netdevice_type = NETDEVICE_TYPE_LOOPBACK;
+      break;
+    default:
+      break;
   }
 
-  void on_connection_state_event(
-      interface_t * interface, nw_interface_t iface, nw_connection_t cnx,
-      nw_connection_state_t state, nw_error_t error) {
+  nw_release(local);
+  nw_release(remote);
+  nw_release(path);
+
+  facelet = facelet_create();
+  if (!facelet) return NULL;
+
+  facelet_set_netdevice(facelet, netdevice);
+  facelet_set_netdevice_type(facelet, netdevice_type);
+  facelet_set_family(facelet, local_sa->sa_family);
+  facelet_set_local_addr(facelet, local_addr);
+  facelet_set_remote_addr(facelet, remote_addr);
+  facelet_set_remote_port(facelet, remote_port);
+
+  return facelet;
+}
+
+void on_connection_state_event(interface_t *interface, nw_interface_t iface,
+                               nw_connection_t cnx, nw_connection_state_t state,
+                               nw_error_t error) {
 #if 1
-    DEBUG("Connection [new state = %s]:\n", connection_state_str[state]);
-    nw_path_t path = nw_connection_copy_current_path(cnx);
-    nw_path_enumerate_interfaces(
-        path,
-        (nw_path_enumerate_interfaces_block_t) ^ (nw_interface_t interface) {
-          const char *name = nw_interface_get_name(interface);
-          printf("NAME=%s\n", name);
-          return true;
-        });
+  DEBUG("Connection [new state = %s]:\n", connection_state_str[state]);
+  nw_path_t path = nw_connection_copy_current_path(cnx);
+  nw_path_enumerate_interfaces(
+      path,
+      (nw_path_enumerate_interfaces_block_t) ^ (nw_interface_t interface) {
+        const char *name = nw_interface_get_name(interface);
+        printf("NAME=%s\n", name);
+        return true;
+      });
 #endif
 
-    /* We should get enough information to create the face and set if up
-     * asap */
+  /* We should get enough information to create the face and set if up
+   * asap */
 
-    nw_endpoint_t remote = nw_connection_copy_endpoint(cnx);
-    errno = error ? nw_error_get_error_code(error) : 0;
+  nw_endpoint_t remote = nw_connection_copy_endpoint(cnx);
+  errno = error ? nw_error_get_error_code(error) : 0;
 
-    switch (state) {
-      case nw_connection_state_waiting:
-        warn("connect to %s port %u (%s) failed, is waiting",
-             nw_endpoint_get_hostname(remote), nw_endpoint_get_port(remote),
-             BONJOUR_PROTOCOL_NAME);
-        break;
+  switch (state) {
+    case nw_connection_state_waiting:
+      warn("connect to %s port %u (%s) failed, is waiting",
+           nw_endpoint_get_hostname(remote), nw_endpoint_get_port(remote),
+           BONJOUR_PROTOCOL_NAME);
+      break;
 
-      case nw_connection_state_preparing:
-        break;
+    case nw_connection_state_preparing:
+      break;
 
-      case nw_connection_state_ready: {
-        printf("info:\n");
-        warn("connection ready");
+    case nw_connection_state_ready: {
+      printf("info:\n");
+      warn("connection ready");
 #if 1
-        WITH_DEBUG({ dump_connection(cnx, 1); });
+      WITH_DEBUG({ dump_connection(cnx, 1); });
 #endif
-        facelet_t *facelet = facelet_create_from_connection(cnx);
-        if (!facelet) return;
-        facelet_set_event(facelet, FACELET_EVENT_CREATE);
-        interface_raise_event(interface, facelet);
-        break;
-      }
-      case nw_connection_state_failed:
-        /* Can we fail with bonjour, or are we always waiting ? */
-        warn("connect to %s port %u (%s) failed",
-             nw_endpoint_get_hostname(remote), nw_endpoint_get_port(remote),
-             BONJOUR_PROTOCOL_NAME);
-        break;
-
-      case nw_connection_state_cancelled:
-        // Release the primary reference on the connection
-        // that was taken at creation time
-        nw_release(cnx);
-        break;
-
-      default: /* nw_connection_state_invalid */
-        /* Should never be called */
-        break;
+      facelet_t *facelet = facelet_create_from_connection(cnx);
+      if (!facelet) return;
+      facelet_set_event(facelet, FACELET_EVENT_CREATE);
+      interface_raise_event(interface, facelet);
+      break;
     }
-
-    nw_release(remote);
+    case nw_connection_state_failed:
+      /* Can we fail with bonjour, or are we always waiting ? */
+      warn("connect to %s port %u (%s) failed",
+           nw_endpoint_get_hostname(remote), nw_endpoint_get_port(remote),
+           BONJOUR_PROTOCOL_NAME);
+      break;
+
+    case nw_connection_state_cancelled:
+      // Release the primary reference on the connection
+      // that was taken at creation time
+      nw_release(cnx);
+      break;
+
+    default: /* nw_connection_state_invalid */
+      /* Should never be called */
+      break;
   }
 
-  void on_connection_path_event(interface_t * interface, nw_interface_t iface,
-                                nw_connection_t cnx, nw_path_t path) {
+  nw_release(remote);
+}
+
+void on_connection_path_event(interface_t *interface, nw_interface_t iface,
+                              nw_connection_t cnx, nw_path_t path) {
 #if 1
-    DEBUG("Connection [path changed]:\n");
-    WITH_DEBUG({ dump_connection(cnx, 1); });
+  DEBUG("Connection [path changed]:\n");
+  WITH_DEBUG({ dump_connection(cnx, 1); });
 #endif
-    /* redundant */ /*
-     DEBUG(1, "Path:\n");
-     dump_path(path, 2);
-     */
-  }
+  /* redundant */ /*
+   DEBUG(1, "Path:\n");
+   dump_path(path, 2);
+   */
+}
 
-  /**
-   * Enumerate main path interfaces
+/**
+ * Enumerate main path interfaces
+ *
+ * We need to create specific dummy connections for each newly discovered
+ * interface
+ *
+ * Currently we only use Bonjour/TCP for remote hICN discovery and connection
+ * path monitoring.
+ */
+void on_interface_event(interface_t *interface, nw_interface_t iface) {
+  /* We can create an hICN face on this interface that will be down until
+   * connected
+   * It is however possible to have two default gateways on the same
+   * interface, or more, or even zero. Somehow we need a strategy, timers, etc
+   * to properly do the job.
    *
-   * We need to create specific dummy connections for each newly discovered
-   * interface
+   * We have to determine:
+   *  - how many faces to build
+   *  - the face type : hICN, tunnel (TCP/UDP)
+   *  - the underlying protocol : v4, v6
    *
-   * Currently we only use Bonjour/TCP for remote hICN discovery and connection
-   * path monitoring.
+   * This depends on the configuration, end host and network capabilities.
+   *
+   * We can rely on several types of discovery:
+   *  - DHCP
+   *  - Bonjour
+   *  - ...
+   *
+   * So far:
+   * - bonjour discovery attempt, we expect to discover one hICN interface
+   *   (how bonjour works with more than one is unclear), after a certain
+   *   time, if none is discovered, we cannot do any tunnel face.
    */
-  void on_interface_event(interface_t * interface, nw_interface_t iface) {
-    /* We can create an hICN face on this interface that will be down until
-     * connected
-     * It is however possible to have two default gateways on the same
-     * interface, or more, or even zero. Somehow we need a strategy, timers, etc
-     * to properly do the job.
-     *
-     * We have to determine:
-     *  - how many faces to build
-     *  - the face type : hICN, tunnel (TCP/UDP)
-     *  - the underlying protocol : v4, v6
-     *
-     * This depends on the configuration, end host and network capabilities.
-     *
-     * We can rely on several types of discovery:
-     *  - DHCP
-     *  - Bonjour
-     *  - ...
-     *
-     * So far:
-     * - bonjour discovery attempt, we expect to discover one hICN interface
-     *   (how bonjour works with more than one is unclear), after a certain
-     *   time, if none is discovered, we cannot do any tunnel face.
-     */
 
-    // OLD CODE
+  // OLD CODE
 
-    /* nw_parameters_create_secure_{udp,tcp} */
-    nw_parameters_t parameters = nw_parameters_create_fn(
-        NW_PARAMETERS_DISABLE_PROTOCOL, /* no (d)tls */
-        NW_PARAMETERS_DEFAULT_CONFIGURATION /* default udp/tcp */);
+  /* nw_parameters_create_secure_{udp,tcp} */
+  nw_parameters_t parameters = nw_parameters_create_fn(
+      NW_PARAMETERS_DISABLE_PROTOCOL, /* no (d)tls */
+      NW_PARAMETERS_DEFAULT_CONFIGURATION /* default udp/tcp */);
 
-    if (!parameters) goto ERR_PARAMETERS;
+  if (!parameters) goto ERR_PARAMETERS;
 
-    nw_parameters_require_interface(parameters, iface);
-    nw_parameters_set_reuse_local_address(parameters, true);
+  nw_parameters_require_interface(parameters, iface);
+  nw_parameters_set_reuse_local_address(parameters, true);
 
 #if defined(MAC_OS_X_VERSION_10_15)
-    /*
-     * Before being able to create a bonjour endpoint, we need to browse for
-     * available services on the local network using the parameters specified
-     * before.
-     */
-    nw_browse_descriptor_t descriptor =
-        nw_browse_descriptor_create_bonjour_service(BONJOUR_SERVICE_TYPE,
-                                                    BONJOUR_SERVICE_DOMAIN);
-    if (!descriptor) {
-      ERROR(
-          "[network_framework.on_interface_event] Failed to create a bonjour "
-          "browse descriptor");
-      goto ERR_DESCRIPTOR;
-    }
+  /*
+   * Before being able to create a bonjour endpoint, we need to browse for
+   * available services on the local network using the parameters specified
+   * before.
+   */
+  nw_browse_descriptor_t descriptor =
+      nw_browse_descriptor_create_bonjour_service(BONJOUR_SERVICE_TYPE,
+                                                  BONJOUR_SERVICE_DOMAIN);
+  if (!descriptor) {
+    ERROR(
+        "[network_framework.on_interface_event] Failed to create a bonjour "
+        "browse descriptor");
+    goto ERR_DESCRIPTOR;
+  }
 
-    nw_browser_t browser = nw_browser_create(descriptor, parameters);
-    nw_browser_set_queue(browser, dispatch_get_main_queue());
-    nw_browser_set_browse_results_changed_handler(browser, ^(
-                                                      nw_browse_result_t result,
-                                                      nw_browse_result_t
-                                                          result2,
-                                                      bool flag) {
-      /* Dump result */
-      printfi(0, "NEW BROWSE RESULT");
-      printfi(1, "Result:");
-      dump_browse_result(result, 2);
-      printfi(1, "Result2:");
-      dump_browse_result(result2, 2);
-      printfi(1, "Flag: %s\n", (flag ? "ON" : "OFF"));
-
-      /* Changes */
-      nw_browse_result_change_t change =
-          nw_browse_result_get_changes(result, result2);
-      switch (change) {
-        case nw_browse_result_change_identical:
-          printfi(2, "The compared services are identical.");
-          break;
-        case nw_browse_result_change_result_added:
-          printfi(2, "A new service was discovered.");
-          break;
+  nw_browser_t browser = nw_browser_create(descriptor, parameters);
+  nw_browser_set_queue(browser, dispatch_get_main_queue());
+  nw_browser_set_browse_results_changed_handler(browser, ^(
+                                                    nw_browse_result_t result,
+                                                    nw_browse_result_t result2,
+                                                    bool flag) {
+    /* Dump result */
+    printfi(0, "NEW BROWSE RESULT");
+    printfi(1, "Result:");
+    dump_browse_result(result, 2);
+    printfi(1, "Result2:");
+    dump_browse_result(result2, 2);
+    printfi(1, "Flag: %s\n", (flag ? "ON" : "OFF"));
+
+    /* Changes */
+    nw_browse_result_change_t change =
+        nw_browse_result_get_changes(result, result2);
+    switch (change) {
+      case nw_browse_result_change_identical:
+        printfi(2, "The compared services are identical.");
+        break;
+      case nw_browse_result_change_result_added:
+        printfi(2, "A new service was discovered.");
+        break;
 
-        case nw_browse_result_change_result_removed:
-          printfi(2, "A previously discovered service was removed.");
-          break;
+      case nw_browse_result_change_result_removed:
+        printfi(2, "A previously discovered service was removed.");
+        break;
 
-        case nw_browse_result_change_txt_record_changed:
-          printfi(2, "The service's associated TXT record changed.");
-          break;
+      case nw_browse_result_change_txt_record_changed:
+        printfi(2, "The service's associated TXT record changed.");
+        break;
 
-        case nw_browse_result_change_interface_added:
-          printfi(2, "The service was discovered over a new interface.");
-          break;
+      case nw_browse_result_change_interface_added:
+        printfi(2, "The service was discovered over a new interface.");
+        break;
 
-        case nw_browse_result_change_interface_removed:
-          printfi(
-              2,
-              "The service was no longer discovered over a certain interface.");
-          break;
-      }
-    });
+      case nw_browse_result_change_interface_removed:
+        printfi(
+            2,
+            "The service was no longer discovered over a certain interface.");
+        break;
+    }
+  });
 
-    nw_browser_start(browser);
+  nw_browser_start(browser);
 //#else
 //#warning "Bonjour discovery only available in MacOS 10.15+"
 #endif /* defined(MAC_OS_X_VERSION_10_15) */
 
-    /*
-     * Now that we have resolve the name of a bonjour remote, we can create a
-     * connection to the corresponding endpoint identified by its name.
-     */
-    nw_endpoint_t endpoint;
+  /*
+   * Now that we have resolve the name of a bonjour remote, we can create a
+   * connection to the corresponding endpoint identified by its name.
+   */
+  nw_endpoint_t endpoint;
 
-    DEBUG("Creating bonjour service towards NAME=%s TYPE=%s DOMAIN=%s",
-          BONJOUR_SERVICE_NAME, BONJOUR_SERVICE_TYPE, BONJOUR_SERVICE_DOMAIN);
-    endpoint = nw_endpoint_create_bonjour_service(
+  DEBUG("Creating bonjour service towards NAME=%s TYPE=%s DOMAIN=%s",
         BONJOUR_SERVICE_NAME, BONJOUR_SERVICE_TYPE, BONJOUR_SERVICE_DOMAIN);
+  endpoint = nw_endpoint_create_bonjour_service(
+      BONJOUR_SERVICE_NAME, BONJOUR_SERVICE_TYPE, BONJOUR_SERVICE_DOMAIN);
 
-    if (!endpoint) {
-      ERROR(
-          "[network_framework.on_interface_event] Failed to create bound "
-          "Bonjour "
-          "connection");
-      goto ERR_ENDPOINT;
-    }
+  if (!endpoint) {
+    ERROR(
+        "[network_framework.on_interface_event] Failed to create bound "
+        "Bonjour "
+        "connection");
+    goto ERR_ENDPOINT;
+  }
 
-    nw_connection_t connection = nw_connection_create(endpoint, parameters);
-    if (!connection) goto ERR_CONNECTION;
+  nw_connection_t connection = nw_connection_create(endpoint, parameters);
+  if (!connection) goto ERR_CONNECTION;
 
-    nw_release(endpoint);
-    nw_release(parameters);
+  nw_release(endpoint);
+  nw_release(parameters);
 
-    /* Remember not to recreate connection */
-    // XXX TODO
+  /* Remember not to recreate connection */
+  // XXX TODO
 
-    /* Setup connection handlers */
+  /* Setup connection handlers */
 
-    nw_connection_set_state_changed_handler(
-        connection, ^(nw_connection_state_t state, nw_error_t error) {
-          on_connection_state_event(interface, iface, connection, state, error);
-        });
+  nw_connection_set_state_changed_handler(
+      connection, ^(nw_connection_state_t state, nw_error_t error) {
+        on_connection_state_event(interface, iface, connection, state, error);
+      });
 
-    nw_connection_set_path_changed_handler(connection, ^(nw_path_t path) {
-      on_connection_path_event(interface, iface, connection, path);
-    });
+  nw_connection_set_path_changed_handler(connection, ^(nw_path_t path) {
+    on_connection_path_event(interface, iface, connection, path);
+  });
 
-    nw_connection_set_better_path_available_handler(connection, ^(bool value) {
+  nw_connection_set_better_path_available_handler(connection, ^(bool value) {
 #if 1
-      DEBUG("Connection [better path = %s]\n", (value ? "true" : "false"));
-      WITH_DEBUG({ dump_connection(connection, 1); });
+    DEBUG("Connection [better path = %s]\n", (value ? "true" : "false"));
+    WITH_DEBUG({ dump_connection(connection, 1); });
 #endif
-    });
+  });
 
-    nw_connection_set_viability_changed_handler(connection, ^(bool value) {
+  nw_connection_set_viability_changed_handler(connection, ^(bool value) {
 #if 1
-      DEBUG("Connection [viable = %s]\n", (value ? "true" : "false"));
-      WITH_DEBUG({
-          // dump_connection(connection, 1);
-      });
+    DEBUG("Connection [viable = %s]\n", (value ? "true" : "false"));
+    WITH_DEBUG({
+        // dump_connection(connection, 1);
+    });
 #endif
 
-      /*
-       * This is the first time we have a connection with address and port
-       * and thus the full identification of an hICN face
-       */
-      facelet_t *facelet = facelet_create_from_connection(connection);
-      if (!facelet) return;
-      facelet_set_event(facelet,
-                        value ? FACELET_EVENT_CREATE : FACELET_EVENT_DELETE);
-      interface_raise_event(interface, facelet);
-    });
+    /*
+     * This is the first time we have a connection with address and port
+     * and thus the full identification of an hICN face
+     */
+    facelet_t *facelet = facelet_create_from_connection(connection);
+    if (!facelet) return;
+    facelet_set_event(facelet,
+                      value ? FACELET_EVENT_CREATE : FACELET_EVENT_DELETE);
+    interface_raise_event(interface, facelet);
+  });
 
-    nw_connection_start(connection);
+  nw_connection_start(connection);
 
-    nw_connection_set_queue(connection, dispatch_get_main_queue());
-    nw_retain(connection);  // Hold a reference until cancelled
+  nw_connection_set_queue(connection, dispatch_get_main_queue());
+  nw_retain(connection);  // Hold a reference until cancelled
 
 #if 1
-    DEBUG("Created Bonjour cnx on interface:");
-    WITH_DEBUG({ dump_interface(iface, 1); });
+  DEBUG("Created Bonjour cnx on interface:");
+  WITH_DEBUG({ dump_interface(iface, 1); });
 #endif
 
-    return;
+  return;
 
-    nw_release(connection);
-  ERR_CONNECTION:
-    nw_release(endpoint);
-  ERR_ENDPOINT:
+  nw_release(connection);
+ERR_CONNECTION:
+  nw_release(endpoint);
+ERR_ENDPOINT:
 #if defined(MAC_OS_X_VERSION_10_15)
-    nw_release(descriptor);
-  ERR_DESCRIPTOR:
+  nw_release(descriptor);
+ERR_DESCRIPTOR:
 #endif /* defined(MAC_OS_X_VERSION_10_15) */
-    nw_release(parameters);
+  nw_release(parameters);
 
-  ERR_PARAMETERS:
-    return;
-  }
+ERR_PARAMETERS:
+  return;
+}
 
-  void on_path_event(interface_t * interface, nw_path_t path) {
-    /* Simplification: we handle path event only once.
-     * Ideally, test whether we discover new interfaces or not
-     */
+void on_path_event(interface_t *interface, nw_path_t path) {
+  /* Simplification: we handle path event only once.
+   * Ideally, test whether we discover new interfaces or not
+   */
 #if 1
-    DEBUG("Path [event]:\n");
-    WITH_DEBUG({ dump_path(path, 1); });
+  DEBUG("Path [event]:\n");
+  WITH_DEBUG({ dump_path(path, 1); });
 #endif
 
-    nw_path_enumerate_interfaces(
-        path, (nw_path_enumerate_interfaces_block_t) ^ (nw_interface_t iface) {
-          on_interface_event(interface, iface);
-          return true;
-        });
-  }
+  nw_path_enumerate_interfaces(
+      path, (nw_path_enumerate_interfaces_block_t) ^ (nw_interface_t iface) {
+        on_interface_event(interface, iface);
+        return true;
+      });
+}
 
-  int nf_initialize(interface_t * interface, void *cfg) {
-    nf_data_t *data = malloc(sizeof(nf_data_t));
-    if (!data) goto ERR_MALLOC;
+int nf_initialize(interface_t *interface, void *cfg) {
+  nf_data_t *data = malloc(sizeof(nf_data_t));
+  if (!data) goto ERR_MALLOC;
 
-    if (cfg) data->cfg = *(network_framework_cfg_t *)cfg;
+  if (cfg) data->cfg = *(network_framework_cfg_t *)cfg;
 
-    data->pm = nw_path_monitor_create();
-    if (!data->pm) goto ERR_PM;
+  data->pm = nw_path_monitor_create();
+  if (!data->pm) goto ERR_PM;
 
-    nw_path_monitor_set_queue(data->pm, dispatch_get_main_queue());
-    nw_path_monitor_set_cancel_handler(data->pm, ^(){
-                                       });
-    nw_path_monitor_set_update_handler(data->pm, ^(nw_path_t path) {
-      on_path_event(interface, path);
-    });
+  nw_path_monitor_set_queue(data->pm, dispatch_get_main_queue());
+  nw_path_monitor_set_cancel_handler(data->pm, ^(){
+                                     });
+  nw_path_monitor_set_update_handler(data->pm, ^(nw_path_t path) {
+    on_path_event(interface, path);
+  });
 
-    // XXX NEEDED ?
-    nw_retain(data->pm);
+  // XXX NEEDED ?
+  nw_retain(data->pm);
 
-    DEBUG("Starting network path monitor");
-    nw_path_monitor_start(data->pm);
+  DEBUG("Starting network path monitor");
+  nw_path_monitor_start(data->pm);
 
-    interface->data = data;
-    return 0;
+  interface->data = data;
+  return 0;
 
-  ERR_PM:
-    free(data);
-  ERR_MALLOC:
-    return -1;
-  }
+ERR_PM:
+  free(data);
+ERR_MALLOC:
+  return -1;
+}
 
-  int nf_finalize(interface_t * interface) {
-    nf_data_t *data = (nf_data_t *)interface->data;
-    if (data->pm) {
-      nw_path_monitor_cancel(data->pm);
-      data->pm = NULL;
-    }
-    return 0;
+int nf_finalize(interface_t *interface) {
+  nf_data_t *data = (nf_data_t *)interface->data;
+  if (data->pm) {
+    nw_path_monitor_cancel(data->pm);
+    data->pm = NULL;
   }
+  return 0;
+}
 
-  const interface_ops_t network_framework_ops = {
-      .type = "network_framework",
-      .initialize = nf_initialize,
-      .finalize = nf_finalize,
-      .on_event = NULL,
-  };
+const interface_ops_t network_framework_ops = {
+    .type = "network_framework",
+    .initialize = nf_initialize,
+    .finalize = nf_finalize,
+    .on_event = NULL,
+};