[HICN-298] Release new hICN app for Android

Change-Id: I43adc62fadf00690b687078d739788dffdc5e566
Signed-off-by: Jordan Augé <jordan.auge+fdio@cisco.com>

17 files changed, 235 insertions, 38 deletions

diff --git a/hicn-light/src/hicn/io/hicnConnection.c b/hicn-light/src/hicn/io/hicnConnection.c
index 124885b33..d56231c38 100644
--- a/hicn-light/src/hicn/io/hicnConnection.c
+++ b/hicn-light/src/hicn/io/hicnConnection.c
@@ -40,6 +40,7 @@
 
 typedef struct hicn_state {
   Forwarder *forwarder;
+  char * interfaceName;
   Logger *logger;
 
   // the hicn listener socket we receive packets on
@@ -96,6 +97,7 @@ static connection_state_t _getState(const IoOperations *ops);
 static void _setState(IoOperations *ops, connection_state_t state);
 static connection_state_t _getAdminState(const IoOperations *ops);
 static void _setAdminState(IoOperations *ops, connection_state_t admin_state);
+static const char * _getInterfaceName(const IoOperations *ops);
 
 /*
  * This assigns a unique pointer to the void * which we use
@@ -127,6 +129,7 @@ static IoOperations _template = {
   .setState = &_setState,
   .getAdminState = &_getAdminState,
   .setAdminState = &_setAdminState,
+  .getInterfaceName = &_getInterfaceName,
 };
 
 // =================================================================
@@ -136,7 +139,7 @@ static bool _saveSockaddr(_HicnState *hicnConnState, const AddressPair *pair);
 static void _refreshProbeDestAddress(_HicnState *hicnConnState,
                                      const uint8_t *message);
 
-IoOperations *hicnConnection_Create(Forwarder *forwarder, int fd,
+IoOperations *hicnConnection_Create(Forwarder *forwarder, const char * interfaceName, int fd,
                                     const AddressPair *pair, bool isLocal) {
   IoOperations *io_ops = NULL;
 
@@ -146,6 +149,7 @@ IoOperations *hicnConnection_Create(Forwarder *forwarder, int fd,
                     sizeof(_HicnState));
 
   hicnConnState->forwarder = forwarder;
+  hicnConnState->interfaceName = strdup(interfaceName);
   hicnConnState->logger = logger_Acquire(forwarder_GetLogger(forwarder));
 
   bool saved = _saveSockaddr(hicnConnState, pair);
@@ -183,6 +187,7 @@ IoOperations *hicnConnection_Create(Forwarder *forwarder, int fd,
     // _saveSockaddr will already log an error, no need for extra log message
     // here
     logger_Release(&hicnConnState->logger);
+    free(hicnConnState->interfaceName);
     parcMemory_Deallocate((void **)&hicnConnState);
   }
 
@@ -223,6 +228,7 @@ static void _destroy(IoOperations **opsPtr) {
   // should I say something to libhicn?
 
   logger_Release(&hicnConnState->logger);
+  free(hicnConnState->interfaceName);
   parcMemory_Deallocate((void **)&hicnConnState);
   parcMemory_Deallocate((void **)&ops);
 
@@ -585,3 +591,11 @@ static void _setAdminState(IoOperations *ops, connection_state_t admin_state) {
       (_HicnState *)ioOperations_GetClosure(ops);
   hicnConnState->admin_state = admin_state;
 }
+
+static const char * _getInterfaceName(const IoOperations *ops)
+{
+  parcAssertNotNull(ops, "Parameter must be non-null");
+  _HicnState *hicnConnState =
+      (_HicnState *)ioOperations_GetClosure(ops);
+  return hicnConnState->interfaceName;
+}
diff --git a/hicn-light/src/hicn/io/hicnConnection.h b/hicn-light/src/hicn/io/hicnConnection.h
index a14024a4e..fec18e1bd 100644
--- a/hicn-light/src/hicn/io/hicnConnection.h
+++ b/hicn-light/src/hicn/io/hicnConnection.h
@@ -48,6 +48,6 @@
  * <#example#>
  * @endcode
  */
-IoOperations *hicnConnection_Create(Forwarder *forwarder, int fd,
+IoOperations *hicnConnection_Create(Forwarder *forwarder, const char * interfaceName, int fd,
                                     const AddressPair *pair, bool isLocal);
 #endif  // hicnConnection_h
diff --git a/hicn-light/src/hicn/io/hicnListener.c b/hicn-light/src/hicn/io/hicnListener.c
index d13dc5b4d..995347d6a 100644
--- a/hicn-light/src/hicn/io/hicnListener.c
+++ b/hicn-light/src/hicn/io/hicnListener.c
@@ -42,6 +42,9 @@
 #define MAX_HICN_RETRY 5
 
 struct hicn_listener {
+
+  char *listenerName;
+
   Forwarder *forwarder;
   Logger *logger;
 
@@ -71,6 +74,8 @@ struct hicn_listener {
 };
 
 static void _destroy(ListenerOps **listenerOpsPtr);
+static const char *_getListenerName(const ListenerOps *ops);
+static const char *_getInterfaceName(const ListenerOps *ops);
 static unsigned _getInterfaceIndex(const ListenerOps *ops);
 static const Address *_getListenAddress(const ListenerOps *ops);
 static EncapType _getEncapType(const ListenerOps *ops);
@@ -85,6 +90,8 @@ static ListenerOps _hicnTemplate = {
   .getListenAddress = &_getListenAddress,
   .getEncapType = &_getEncapType,
   .getSocket = &_getSocket,
+  .getInterfaceName = &_getInterfaceName,
+  .getListenerName = &_getListenerName,
   .createConnection = &_createNewConnection,
   .lookupConnection = &_lookupConnection,
 };
@@ -125,6 +132,9 @@ ListenerOps *hicnListener_CreateInet(Forwarder *forwarder, char *symbolic,
                     sizeof(HicnListener));
 
   hicn->forwarder = forwarder;
+  hicn->listenerName = parcMemory_StringDuplicate(symbolic, strlen(symbolic));
+  hicn->logger = logger_Acquire(forwarder_GetLogger(forwarder));
+
   hicn->logger = logger_Acquire(forwarder_GetLogger(forwarder));
 
   hicn->conn_id = forwarder_GetNextConnectionId(forwarder);
@@ -164,6 +174,7 @@ ListenerOps *hicnListener_CreateInet(Forwarder *forwarder, char *symbolic,
     }
     logger_Release(&hicn->logger);
     addressDestroy(&hicn->localAddress);
+    parcMemory_Deallocate((void **)&hicn->listenerName);
     parcMemory_Deallocate((void **)&hicn);
     return NULL;
   }
@@ -206,6 +217,7 @@ ListenerOps *hicnListener_CreateInet6(Forwarder *forwarder, char *symbolic,
                     sizeof(HicnListener));
 
   hicn->forwarder = forwarder;
+  hicn->listenerName = parcMemory_StringDuplicate(symbolic, strlen(symbolic));
   hicn->logger = logger_Acquire(forwarder_GetLogger(forwarder));
 
   hicn->conn_id = forwarder_GetNextConnectionId(forwarder);
@@ -255,6 +267,7 @@ ListenerOps *hicnListener_CreateInet6(Forwarder *forwarder, char *symbolic,
     }
     logger_Release(&hicn->logger);
     addressDestroy(&hicn->localAddress);
+    parcMemory_Deallocate((void **)&hicn->listenerName);
     parcMemory_Deallocate((void **)&hicn);
     return NULL;
   }
@@ -421,6 +434,15 @@ static void _destroy(ListenerOps **listenerOpsPtr) {
   *listenerOpsPtr = NULL;
 }
 
+static const char *_getListenerName(const ListenerOps *ops) {
+  HicnListener *hicn = (HicnListener *)ops->context;
+  return hicn->listenerName;
+}
+static const char *_getInterfaceName(const ListenerOps *ops) {
+  const char *interfaceName = "";
+  return interfaceName;
+}
+
 static unsigned _getInterfaceIndex(const ListenerOps *ops) {
   HicnListener *hicn = (HicnListener *)ops->context;
   return hicn->conn_id;
@@ -468,7 +490,7 @@ static unsigned _createNewConnection(ListenerOps * listener, int fd,
   bool isLocal = false;
 
   // udpConnection_Create takes ownership of the pair
-  IoOperations *ops = hicnConnection_Create(hicn->forwarder, fd, pair, isLocal);
+  IoOperations *ops = hicnConnection_Create(hicn->forwarder, listener->getInterfaceName(listener), fd, pair, isLocal);
   Connection *conn = connection_Create(ops);
 
   connectionTable_Add(forwarder_GetConnectionTable(hicn->forwarder), conn);
diff --git a/hicn-light/src/hicn/io/hicnTunnel.c b/hicn-light/src/hicn/io/hicnTunnel.c
index baf10c637..fd5acc680 100644
--- a/hicn-light/src/hicn/io/hicnTunnel.c
+++ b/hicn-light/src/hicn/io/hicnTunnel.c
@@ -56,7 +56,7 @@ IoOperations *hicnTunnel_CreateOnListener(Forwarder *forwarder,
       AddressPair *pair = addressPair_Create(localAddress, remoteAddress);
       bool isLocal = false;
       int fd = localListener->getSocket(localListener);
-      ops = hicnConnection_Create(forwarder, fd, pair, isLocal);
+      ops = hicnConnection_Create(forwarder, localListener->getInterfaceName(localListener), fd, pair, isLocal);
 
       addressPair_Release(&pair);
     } else {
diff --git a/hicn-light/src/hicn/io/ioOperations.c b/hicn-light/src/hicn/io/ioOperations.c
index bbcea41f8..31e37a461 100644
--- a/hicn-light/src/hicn/io/ioOperations.c
+++ b/hicn-light/src/hicn/io/ioOperations.c
@@ -83,3 +83,7 @@ connection_state_t ioOperations_GetAdminState(const IoOperations *ops) {
 void ioOperations_SetAdminState(IoOperations *ops, connection_state_t admin_state) {
   ops->setAdminState(ops, admin_state);
 }
+
+const char * ioOperations_GetInterfaceName(const IoOperations *ops) {
+    return ops->getInterfaceName(ops);
+}
diff --git a/hicn-light/src/hicn/io/ioOperations.h b/hicn-light/src/hicn/io/ioOperations.h
index 7a48b7e3e..c8a107199 100644
--- a/hicn-light/src/hicn/io/ioOperations.h
+++ b/hicn-light/src/hicn/io/ioOperations.h
@@ -67,6 +67,8 @@ typedef struct io_ops IoOperations;
  * state).
  * @constant setAdminState Allows to set the administrative state of a
  * connection.
+ * @constant getInterfaceName Returns the interface name associated to a
+ * connection.
  * @discussion <#Discussion#>
  */
 struct io_ops {
@@ -87,6 +89,7 @@ struct io_ops {
   void (*setState)(IoOperations *ops, connection_state_t state);
   connection_state_t (*getAdminState)(const IoOperations *ops);
   void (*setAdminState)(IoOperations *ops, connection_state_t admin_state);
+  const char * (*getInterfaceName)(const IoOperations *ops);
 };
 
 /**
@@ -413,4 +416,12 @@ connection_state_t ioOperations_GetAdminState(const IoOperations *ops);
  */
 void ioOperations_SetAdminState(IoOperations *ops, connection_state_t admin_state);
 
+/**
+ * Sets the interface name associated to the connection.
+ *
+ * @param [in] ops The connection implementation.
+ * @return the name associated to the connection (const char *)
+ */
+const char * ioOperations_GetInterfaceName(const IoOperations *ops);
+
 #endif  // io_h
diff --git a/hicn-light/src/hicn/io/listener.h b/hicn-light/src/hicn/io/listener.h
index ef1955b12..1b473be59 100644
--- a/hicn-light/src/hicn/io/listener.h
+++ b/hicn-light/src/hicn/io/listener.h
@@ -55,6 +55,15 @@ struct listener_ops {
   void (*destroy)(ListenerOps **listenerOpsPtr);
 
   /**
+   * Returns the listener name of the listener.
+   *
+   * @param [in] ops Pointer to this structure
+   *
+   * @return the listener name of the listener
+   */
+  const char *(*getListenerName)(const ListenerOps *ops);
+
+  /**
    * Returns the interface index of the listener.
    *
    * @param [in] ops Pointer to this structure
@@ -82,6 +91,15 @@ struct listener_ops {
   EncapType (*getEncapType)(const ListenerOps *ops);
 
   /**
+   * Returns the interface name of the listener.
+   *
+   * @param [in] ops Pointer to this structure
+   *
+   * @return the interface name of the listener
+   */
+  const char *(*getInterfaceName)(const ListenerOps *ops);
+
+  /**
    * Returns the underlying socket associated with the listener
    *
    * Not all listeners are capable of returning a useful socket.  In those
diff --git a/hicn-light/src/hicn/io/listenerSet.c b/hicn-light/src/hicn/io/listenerSet.c
index 982373b63..3e44973d7 100644
--- a/hicn-light/src/hicn/io/listenerSet.c
+++ b/hicn-light/src/hicn/io/listenerSet.c
@@ -130,3 +130,39 @@ ListenerOps *listenerSet_Find(const ListenerSet *set, EncapType encapType,
 
   return match;
 }
+
+ListenerOps *listenerSet_FindById(const ListenerSet *set, unsigned id) {
+  parcAssertNotNull(set, "Parameter set must be non-null");
+
+  ListenerOps *match = NULL;
+
+  for (size_t i = 0; i < parcArrayList_Size(set->listOfListeners) && !match;
+       i++) {
+    ListenerOps *ops = parcArrayList_Get(set->listOfListeners, i);
+    parcAssertNotNull(ops, "Got null listener ops at index %zu", i);
+    if (ops->getInterfaceIndex(ops) == id) {
+        match = ops;
+    }
+  }
+
+  return match;
+}
+
+int listenerSet_FindIdByListenerName(const ListenerSet *set, const char *listenerName ) {
+  parcAssertNotNull(set, "Parameter set must be non-null");
+  parcAssertNotNull(listenerName, "Parameter listenerName must be non-null");
+
+  ListenerOps *match = NULL;
+  int index = -1;
+  for (size_t i = 0; i < parcArrayList_Size(set->listOfListeners) && !match;
+       i++) {
+    ListenerOps *ops = parcArrayList_Get(set->listOfListeners, i);
+    parcAssertNotNull(ops, "Got null listener ops at index %zu", i);
+    if (ops->getListenerName(ops) && strcmp(ops->getListenerName(ops), listenerName) == 0) {
+        index = ops->getInterfaceIndex(ops);
+        break;
+    }
+  }
+
+  return index;
+}
diff --git a/hicn-light/src/hicn/io/listenerSet.h b/hicn-light/src/hicn/io/listenerSet.h
index 8d15a2736..c8937fa02 100644
--- a/hicn-light/src/hicn/io/listenerSet.h
+++ b/hicn-light/src/hicn/io/listenerSet.h
@@ -134,4 +134,41 @@ ListenerOps *listenerSet_Get(const ListenerSet *set, size_t index);
  */
 ListenerOps *listenerSet_Find(const ListenerSet *set, EncapType encapType,
                               const Address *localAddress);
+
+
+/**
+ * Looks up a listener by its id
+ *
+ * <#Paragraphs Of Explanation#>
+ *
+ * @param [in] set An allocated listener set
+ * @param [in] id of the listener
+ *
+ * @retval non-null The listener matching the query
+ * @retval null Does not exist
+ *
+ * Example:
+ * @code
+ *
+ * @endcode
+ */
+ListenerOps *listenerSet_FindById(const ListenerSet *set, unsigned id);
+/**
+ * Looks up a listener by its id
+ *
+ * <#Paragraphs Of Explanation#>
+ *
+ * @param [in] set An allocated listener set
+ * @param [in] name of the listener
+ *
+ * @retval greater or equal to 0 The listener matching the query
+ * @retval -1 Does not exist
+ *
+ * Example:
+ * @code
+ *
+ * @endcode
+ */
+int listenerSet_FindIdByListenerName(const ListenerSet *set, const char *listenerName);
+
 #endif
diff --git a/hicn-light/src/hicn/io/streamConnection.c b/hicn-light/src/hicn/io/streamConnection.c
index ce2341cb8..224f129f7 100644
--- a/hicn-light/src/hicn/io/streamConnection.c
+++ b/hicn-light/src/hicn/io/streamConnection.c
@@ -47,6 +47,7 @@ static void _conn_eventcb(PARCEventQueue *bufferEventVector,
 
 typedef struct stream_state {
   Forwarder *forwarder;
+  char * interfaceName;
   Logger *logger;
 
   int fd;
@@ -90,6 +91,7 @@ static connection_state_t _streamConnection_getState(const IoOperations *ops);
 static void _streamConnection_setState(IoOperations *ops, connection_state_t state);
 static connection_state_t _streamConnection_getAdminState(const IoOperations *ops);
 static void _streamConnection_setAdminState(IoOperations *ops, connection_state_t admin_state);
+static const char * _streamConnection_getInterfaceName(const IoOperations *ops);
 
 /*
  * This assigns a unique pointer to the void * which we use
@@ -121,6 +123,7 @@ static IoOperations _template = {
     .setState = &_streamConnection_setState,
     .getAdminState = &_streamConnection_getAdminState,
     .setAdminState = &_streamConnection_setAdminState,
+    .getInterfaceName = &_streamConnection_getInterfaceName,
 };
 
 IoOperations *streamConnection_AcceptConnection(Forwarder *forwarder, int fd,
@@ -137,6 +140,7 @@ IoOperations *streamConnection_AcceptConnection(Forwarder *forwarder, int fd,
       PARCEventQueueOption_CloseOnFree | PARCEventQueueOption_DeferCallbacks);
 
   stream->forwarder = forwarder;
+  stream->interfaceName = NULL;
   stream->logger = logger_Acquire(forwarder_GetLogger(forwarder));
   stream->fd = fd;
   stream->id = forwarder_GetNextConnectionId(forwarder);
@@ -191,6 +195,7 @@ IoOperations *streamConnection_OpenConnection(Forwarder *forwarder,
                     sizeof(_StreamState));
 
   stream->forwarder = forwarder;
+  stream->interfaceName = NULL;
   stream->logger = logger_Acquire(forwarder_GetLogger(forwarder));
   stream->fd = parcEventQueue_GetFileDescriptor(bufferEventVector);
   stream->bufferEventVector = bufferEventVector;
@@ -606,7 +611,7 @@ static void _conn_readcb(PARCEventQueue *event, PARCEventType type,
 
     } else {
       parcAssertTrue(false,
-                     "(Local stream connection) malformend packet received");
+                     "(Local stream connection) malformed packet received");
     }
   }
 
@@ -728,3 +733,11 @@ static void _streamConnection_setAdminState(IoOperations *ops, connection_state_
       (_StreamState *)ioOperations_GetClosure(ops);
   stream->admin_state = admin_state;
 }
+
+static const char * _streamConnection_getInterfaceName(const IoOperations *ops)
+{
+  parcAssertNotNull(ops, "Parameter must be non-null");
+  _StreamState *stream =
+      (_StreamState *)ioOperations_GetClosure(ops);
+  return stream->interfaceName;
+}
diff --git a/hicn-light/src/hicn/io/tcpListener.c b/hicn-light/src/hicn/io/tcpListener.c
index cc6fdbba8..4464edf28 100644
--- a/hicn-light/src/hicn/io/tcpListener.c
+++ b/hicn-light/src/hicn/io/tcpListener.c
@@ -30,6 +30,8 @@
 #include <parc/assert/parc_Assert.h>
 
 typedef struct tcp_listener {
+  char *listenerName;
+
   Forwarder *forwarder;
   Logger *logger;
 
@@ -38,6 +40,7 @@ typedef struct tcp_listener {
   Address *localAddress;
 
   unsigned id;
+  char *interfaceName;
 
   // is the localAddress as 127.0.0.0 address?
   bool isLocalAddressLocal;
@@ -46,30 +49,36 @@ typedef struct tcp_listener {
 static void _tcpListener_Destroy(_TcpListener **listenerPtr);
 
 static void _tcpListener_OpsDestroy(ListenerOps **listenerOpsPtr);
+static const char *_tcpListener_ListenerName(const ListenerOps *ops);
 static unsigned _tcpListener_OpsGetInterfaceIndex(const ListenerOps *ops);
 static const Address *_tcpListener_OpsGetListenAddress(const ListenerOps *ops);
+static const char *_tcpListener_InterfaceName(const ListenerOps *ops);
 static EncapType _tcpListener_OpsGetEncapType(const ListenerOps *ops);
 
 static ListenerOps _tcpTemplate = {
     .context = NULL,
     .destroy = &_tcpListener_OpsDestroy,
+    .getListenerName = &_tcpListener_ListenerName,
     .getInterfaceIndex = &_tcpListener_OpsGetInterfaceIndex,
     .getListenAddress = &_tcpListener_OpsGetListenAddress,
     .getEncapType = &_tcpListener_OpsGetEncapType,
+    .getInterfaceName = &_tcpListener_InterfaceName,
     .getSocket = NULL};
 
 // STREAM daemon listener callback
 static void _tcpListener_Listen(int, struct sockaddr *, int socklen,
                                 void *tcpVoid);
 
-ListenerOps *tcpListener_CreateInet6(Forwarder *forwarder,
-                                     struct sockaddr_in6 sin6) {
+ListenerOps *tcpListener_CreateInet6(Forwarder *forwarder, char *listenerName,
+                                     struct sockaddr_in6 sin6, char *interfaceName) {
   _TcpListener *tcp = parcMemory_AllocateAndClear(sizeof(_TcpListener));
   parcAssertNotNull(tcp, "parcMemory_AllocateAndClear(%zu) returned NULL",
                     sizeof(_TcpListener));
 
   tcp->forwarder = forwarder;
+  tcp->listenerName = parcMemory_StringDuplicate(listenerName, strlen(listenerName));
   tcp->logger = logger_Acquire(forwarder_GetLogger(forwarder));
+  tcp->interfaceName = parcMemory_StringDuplicate(interfaceName, strlen(interfaceName));
 
   tcp->listener = dispatcher_CreateListener(
       forwarder_GetDispatcher(forwarder), _tcpListener_Listen, (void *)tcp, -1,
@@ -107,8 +116,8 @@ ListenerOps *tcpListener_CreateInet6(Forwarder *forwarder,
   return ops;
 }
 
-ListenerOps *tcpListener_CreateInet(Forwarder *forwarder,
-                                    struct sockaddr_in sin) {
+ListenerOps *tcpListener_CreateInet(Forwarder *forwarder, char *listenerName,
+                                    struct sockaddr_in sin, char *interfaceName) {
   _TcpListener *tcp = parcMemory_AllocateAndClear(sizeof(_TcpListener));
   parcAssertNotNull(tcp, "parcMemory_AllocateAndClear(%zu) returned NULL",
                     sizeof(_TcpListener));
@@ -164,6 +173,9 @@ static void _tcpListener_Destroy(_TcpListener **listenerPtr) {
     parcMemory_Deallocate((void **)&str);
   }
 
+  parcMemory_Deallocate((void **)&tcp->listenerName);
+  parcMemory_Deallocate((void **)&tcp->interfaceName);
+
   logger_Release(&tcp->logger);
   dispatcher_DestroyListener(forwarder_GetDispatcher(tcp->forwarder),
                              &tcp->listener);
@@ -174,6 +186,16 @@ static void _tcpListener_Destroy(_TcpListener **listenerPtr) {
 
 // ==================================================
 
+static const char *_tcpListener_ListenerName(const ListenerOps *ops) {
+  _TcpListener *tcp = (_TcpListener *)ops->context;
+  return tcp->listenerName;
+}
+
+static const char *_tcpListener_InterfaceName(const ListenerOps *ops) {
+  _TcpListener *tcp = (_TcpListener *)ops->context;
+  return tcp->interfaceName;
+}
+
 static void _tcpListener_Listen(int fd, struct sockaddr *sa, int socklen,
                                 void *tcpVoid) {
   _TcpListener *tcp = (_TcpListener *)tcpVoid;
diff --git a/hicn-light/src/hicn/io/tcpListener.h b/hicn-light/src/hicn/io/tcpListener.h
index df0bbea1e..a841738e5 100644
--- a/hicn-light/src/hicn/io/tcpListener.h
+++ b/hicn-light/src/hicn/io/tcpListener.h
@@ -33,8 +33,8 @@
 #include <hicn/io/listener.h>
 #include <stdlib.h>
 
-ListenerOps *tcpListener_CreateInet6(Forwarder *forwarder,
-                                     struct sockaddr_in6 sin6);
-ListenerOps *tcpListener_CreateInet(Forwarder *forwarder,
-                                    struct sockaddr_in sin);
+ListenerOps *tcpListener_CreateInet6(Forwarder *forwarder, char *listenerName,
+                                     struct sockaddr_in6 sin6, char *interfaceName);
+ListenerOps *tcpListener_CreateInet(Forwarder *forwarder, char *listenerName,
+                                    struct sockaddr_in sin, char *interfaceName);
 #endif  // tcpListener_h
diff --git a/hicn-light/src/hicn/io/udpConnection.c b/hicn-light/src/hicn/io/udpConnection.c
index 78157f01f..9ad70403f 100644
--- a/hicn-light/src/hicn/io/udpConnection.c
+++ b/hicn-light/src/hicn/io/udpConnection.c
@@ -40,6 +40,7 @@
 
 typedef struct udp_state {
   Forwarder *forwarder;
+  char * interfaceName;
   Logger *logger;
 
   // the udp listener socket we receive packets on
@@ -81,6 +82,7 @@ static connection_state_t _getState(const IoOperations *ops);
 static void _setState(IoOperations *ops, connection_state_t state);
 static connection_state_t _getAdminState(const IoOperations *ops);
 static void _setAdminState(IoOperations *ops, connection_state_t admin_state);
+static const char * _getInterfaceName(const IoOperations *ops);
 
 /*
  * This assigns a unique pointer to the void * which we use
@@ -112,6 +114,7 @@ static IoOperations _template = {
   .setState = &_setState,
   .getAdminState = &_getAdminState,
   .setAdminState = &_setAdminState,
+  .getInterfaceName = &_getInterfaceName,
 };
 
 // =================================================================
@@ -119,7 +122,7 @@ static IoOperations _template = {
 static void _setConnectionState(_UdpState *Udp, bool isUp);
 static bool _saveSockaddr(_UdpState *udpConnState, const AddressPair *pair);
 
-IoOperations *udpConnection_Create(Forwarder *forwarder, int fd,
+IoOperations *udpConnection_Create(Forwarder *forwarder, const char * interfaceName, int fd,
                                    const AddressPair *pair, bool isLocal) {
   IoOperations *io_ops = NULL;
 
@@ -129,6 +132,7 @@ IoOperations *udpConnection_Create(Forwarder *forwarder, int fd,
                     sizeof(_UdpState));
 
   udpConnState->forwarder = forwarder;
+  udpConnState->interfaceName = strdup(interfaceName);
   udpConnState->logger = logger_Acquire(forwarder_GetLogger(forwarder));
 
   bool saved = _saveSockaddr(udpConnState, pair);
@@ -166,6 +170,8 @@ IoOperations *udpConnection_Create(Forwarder *forwarder, int fd,
     // _saveSockaddr will already log an error, no need for extra log message
     // here
     logger_Release(&udpConnState->logger);
+
+    free(udpConnState->interfaceName);
     parcMemory_Deallocate((void **)&udpConnState);
   }
 
@@ -202,6 +208,7 @@ static void _destroy(IoOperations **opsPtr) {
   // that when its done
 
   logger_Release(&udpConnState->logger);
+  free(udpConnState->interfaceName);
   parcMemory_Deallocate((void **)&udpConnState);
   parcMemory_Deallocate((void **)&ops);
 
@@ -435,3 +442,11 @@ static void _setAdminState(IoOperations *ops, connection_state_t admin_state) {
       (_UdpState *)ioOperations_GetClosure(ops);
   udpConnState->admin_state = admin_state;
 }
+
+static const char * _getInterfaceName(const IoOperations *ops)
+{
+  parcAssertNotNull(ops, "Parameter must be non-null");
+  _UdpState *udpConnState =
+      (_UdpState *)ioOperations_GetClosure(ops);
+  return udpConnState->interfaceName;
+}
diff --git a/hicn-light/src/hicn/io/udpConnection.h b/hicn-light/src/hicn/io/udpConnection.h
index 07c4da9bd..9fbc5348b 100644
--- a/hicn-light/src/hicn/io/udpConnection.h
+++ b/hicn-light/src/hicn/io/udpConnection.h
@@ -48,6 +48,6 @@
  * <#example#>
  * @endcode
  */
-IoOperations *udpConnection_Create(Forwarder *forwarder, int fd,
+IoOperations *udpConnection_Create(Forwarder *forwarder, const char * interfaceName, int fd,
                                    const AddressPair *pair, bool isLocal);
 #endif  // udpConnection_h
diff --git a/hicn-light/src/hicn/io/udpListener.c b/hicn-light/src/hicn/io/udpListener.c
index f6b434fed..050ca104c 100644
--- a/hicn-light/src/hicn/io/udpListener.c
+++ b/hicn-light/src/hicn/io/udpListener.c
@@ -41,6 +41,7 @@
 
 struct udp_listener {
   Forwarder *forwarder;
+  char *listenerName;
   Logger *logger;
 
   PARCEvent *udp_event;
@@ -48,13 +49,16 @@ struct udp_listener {
   uint16_t port;
 
   unsigned id;
+  char *interfaceName;
   Address *localAddress;
 };
 
 static void _destroy(ListenerOps **listenerOpsPtr);
+static const char *_getListenerName(const ListenerOps *ops);
 static unsigned _getInterfaceIndex(const ListenerOps *ops);
 static const Address *_getListenAddress(const ListenerOps *ops);
 static EncapType _getEncapType(const ListenerOps *ops);
+static const char *_getInterfaceName(const ListenerOps *ops);
 static int _getSocket(const ListenerOps *ops);
 static unsigned _createNewConnection(ListenerOps *listener, int fd, const AddressPair *pair);
 static const Connection * _lookupConnection(ListenerOps * listener, const AddressPair *pair);
@@ -66,8 +70,10 @@ static ListenerOps udpTemplate = {
   .getListenAddress = &_getListenAddress,
   .getEncapType = &_getEncapType,
   .getSocket = &_getSocket,
+  .getListenerName = &_getListenerName,
   .createConnection = &_createNewConnection,
   .lookupConnection = &_lookupConnection,
+  .getInterfaceName = &_getInterfaceName,
 };
 
 static void _readcb(int fd, PARCEventType what, void * listener_void);
@@ -76,19 +82,16 @@ static void _readcb(int fd, PARCEventType what, void * listener_void);
 extern int bindSocket(int sock, const char* ifname);
 #endif
 
-#ifdef __linux__
-ListenerOps *udpListener_CreateInet6(Forwarder *forwarder,
+ListenerOps *udpListener_CreateInet6(Forwarder *forwarder, char *listenerName,
                                      struct sockaddr_in6 sin6, const char *interfaceName) {
-#else
-ListenerOps *udpListener_CreateInet6(Forwarder *forwarder,
-                                     struct sockaddr_in6 sin6) {
-#endif
   ListenerOps *ops = NULL;
 
   UdpListener *udp = parcMemory_AllocateAndClear(sizeof(UdpListener));
   parcAssertNotNull(udp, "parcMemory_AllocateAndClear(%zu) returned NULL",
                     sizeof(UdpListener));
   udp->forwarder = forwarder;
+  udp->listenerName = parcMemory_StringDuplicate(listenerName, strlen(listenerName));
+  udp->interfaceName = parcMemory_StringDuplicate(interfaceName, strlen(interfaceName));
   udp->logger = logger_Acquire(forwarder_GetLogger(forwarder));
   udp->localAddress = addressCreateFromInet6(&sin6);
   udp->id = forwarder_GetNextConnectionId(forwarder);
@@ -172,6 +175,8 @@ ListenerOps *udpListener_CreateInet6(Forwarder *forwarder,
                  myerrno, strerror(myerrno));
       parcMemory_Deallocate((void **)&str);
     }
+    parcMemory_Deallocate((void **)&udp->listenerName);
+    parcMemory_Deallocate((void **)&udp->interfaceName);
 #ifndef _WIN32
     close(udp->udp_socket);
 #else
@@ -185,19 +190,16 @@ ListenerOps *udpListener_CreateInet6(Forwarder *forwarder,
   return ops;
 }
 
-#ifdef __linux__
-ListenerOps *udpListener_CreateInet(Forwarder *forwarder,
+ListenerOps *udpListener_CreateInet(Forwarder *forwarder, char *listenerName,
                                     struct sockaddr_in sin, const char *interfaceName) {
-#else
-ListenerOps *udpListener_CreateInet(Forwarder *forwarder,
-                                    struct sockaddr_in sin) {
-#endif
   ListenerOps *ops = NULL;
 
   UdpListener *udp = parcMemory_AllocateAndClear(sizeof(UdpListener));
   parcAssertNotNull(udp, "parcMemory_AllocateAndClear(%zu) returned NULL",
                     sizeof(UdpListener));
   udp->forwarder = forwarder;
+  udp->listenerName = parcMemory_StringDuplicate(listenerName, strlen(listenerName));
+  udp->interfaceName = parcMemory_StringDuplicate(interfaceName, strlen(interfaceName));
   udp->logger = logger_Acquire(forwarder_GetLogger(forwarder));
   udp->localAddress = addressCreateFromInet(&sin);
   udp->id = forwarder_GetNextConnectionId(forwarder);
@@ -315,6 +317,16 @@ static void udpListener_Destroy(UdpListener **listenerPtr) {
   *listenerPtr = NULL;
 }
 
+static const char *_getListenerName(const ListenerOps *ops) {
+  UdpListener *udp = (UdpListener *)ops->context;
+  return udp->listenerName;
+}
+
+static const char *_getInterfaceName(const ListenerOps *ops) {
+  UdpListener *udp = (UdpListener *)ops->context;
+  return udp->interfaceName;
+}
+
 static void _destroy(ListenerOps **listenerOpsPtr) {
   ListenerOps *ops = *listenerOpsPtr;
   UdpListener *udp = (UdpListener *)ops->context;
@@ -420,7 +432,7 @@ static unsigned _createNewConnection(ListenerOps * listener, int fd,
   }
 
   // metisUdpConnection_Create takes ownership of the pair
-  IoOperations *ops = udpConnection_Create(udp->forwarder, fd, pair, isLocal);
+  IoOperations *ops = udpConnection_Create(udp->forwarder, udp->interfaceName, fd, pair, isLocal);
   Connection *conn = connection_Create(ops);
   // connection_AllowWldrAutoStart(conn);
 
diff --git a/hicn-light/src/hicn/io/udpListener.h b/hicn-light/src/hicn/io/udpListener.h
index 81d191eab..62c09e4db 100644
--- a/hicn-light/src/hicn/io/udpListener.h
+++ b/hicn-light/src/hicn/io/udpListener.h
@@ -27,16 +27,9 @@
 struct udp_listener;
 typedef struct udp_listener UdpListener;
 
-#ifdef __linux__
-ListenerOps *udpListener_CreateInet6(Forwarder *forwarder,
+ListenerOps *udpListener_CreateInet6(Forwarder *forwarder, char *listenerName,
                                      struct sockaddr_in6 sin6, const char *if_bind);
-ListenerOps *udpListener_CreateInet(Forwarder *forwarder,
+ListenerOps *udpListener_CreateInet(Forwarder *forwarder, char *listenerName,
                                     struct sockaddr_in sin, const char *if_bind);
-#else
-ListenerOps *udpListener_CreateInet6(Forwarder *forwarder,
-                                     struct sockaddr_in6 sin6);
-ListenerOps *udpListener_CreateInet(Forwarder *forwarder,
-                                    struct sockaddr_in sin);
-#endif
 // void udpListener_SetPacketType(ListenerOps *ops, MessagePacketType type);
 #endif  // udpListener_h
diff --git a/hicn-light/src/hicn/io/udpTunnel.c b/hicn-light/src/hicn/io/udpTunnel.c
index 2f2f84105..9f5249e3c 100644
--- a/hicn-light/src/hicn/io/udpTunnel.c
+++ b/hicn-light/src/hicn/io/udpTunnel.c
@@ -60,7 +60,7 @@ IoOperations *udpTunnel_CreateOnListener(Forwarder *forwarder,
       int fd = localListener->getSocket(localListener);
       // udpListener_SetPacketType(localListener,
       //                MessagePacketType_ContentObject);
-      ops = udpConnection_Create(forwarder, fd, pair, isLocal);
+      ops = udpConnection_Create(forwarder, localListener->getInterfaceName(localListener), fd, pair, isLocal);
 
       addressPair_Release(&pair);
     } else {