[HICN-252] Add per-application policy framework to hicn-light forwarder

Change-Id: I0531cd7a7de179581295ae34766c81cd9cf3e172
Signed-off-by: Jordan Augé <jordan.auge+fdio@cisco.com>
Signed-off-by: Mauro Sardara <msardara@cisco.com>
Co-authored-by: Mauro Sardara <msardara@cisco.com>

44 files changed, 4836 insertions, 0 deletions

diff --git a/ctrl/facemgr/src/CMakeLists.txt b/ctrl/facemgr/src/CMakeLists.txt
new file mode 100644
index 000000000..e7dbda5c1
--- /dev/null
+++ b/ctrl/facemgr/src/CMakeLists.txt
@@ -0,0 +1,112 @@
+# Copyright (c) 2017-2019 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.
+
+if(UNIX AND NOT APPLE)
+    set(LINUX TRUE)
+endif()
+
+set(COMPILER_DEFINITIONS
+  "-DWITH_POLICY"
+)
+
+set(HEADER_FILES
+#cache.h
+    common.h
+    error.h
+    event.h
+    face.h
+    face_cache.h
+    face_rules.h
+    interface.h
+    interface_map.h
+    interface_ops_map.h
+    util/hash.h
+    util/ip_address.h
+    util/log.h
+    util/map.h
+    util/policy.h
+    util/set.h
+    util/token.h
+    util/types.h
+
+)
+
+set(SOURCE_FILES
+#   cache.c
+    error.c
+    event.c
+    face.c
+    face_cache.c
+    face_rules.c
+    interface.c
+    interface_map.c
+    interface_ops_map.c
+    facemgr.c
+    util/log.c
+    util/policy.c
+)
+
+set(INCLUDE_DIRS
+    ./
+    ../includes/
+    ${CONFIG_INCLUDE_DIR}
+    ${LIBEVENT_INCLUDE_DIR}
+    ${LIBHICNCTRL_INCLUDE_DIRS}
+)
+
+set(LIBRARIES
+    ${CONFIG_LIBRARY}
+    ${LIBEVENT_LIBRARY}
+    ${LIBHICNCTRL_LIBRARIES}
+)
+
+add_subdirectory(interfaces)
+
+if (ANDROID_API)
+    build_library(${FACE_MGR}
+        STATIC
+        SOURCES ${SOURCE_FILES}
+        INSTALL_HEADERS ${TO_INSTALL_HEADER_FILES}
+        DEPENDS ${DEPENDENCIES}
+        COMPONENT ${FACE_MGR}
+        INCLUDE_DIRS ${INCLUDE_DIRS}
+        INSTALL_ROOT_DIR hicn
+        DEFINITIONS ${COMPILER_DEFINITIONS}
+    )
+else ()
+    build_library(${FACE_MGR}
+        STATIC NO_DEV
+        SOURCES ${SOURCE_FILES}
+        INSTALL_HEADERS ${TO_INSTALL_HEADER_FILES}
+        DEPENDS ${DEPENDENCIES}
+        COMPONENT ${FACE_MGR}
+        INCLUDE_DIRS ${INCLUDE_DIRS}
+        INSTALL_ROOT_DIR hicn
+        DEFINITIONS ${COMPILER_DEFINITIONS}
+    )
+endif ()
+
+if(NOT ANDROID_API AND NOT COMPILE_FOR_IOS)
+    list(APPEND DAEMON_SRC
+      main.c
+    )
+
+    build_executable(${FACE_MGR}
+      SOURCES ${DAEMON_SRC}
+      LINK_LIBRARIES ${FACE_MGR}.static ${LIBRARIES}
+      DEPENDS ${FACE_MGR}.static
+      COMPONENT ${FACE_MGR}
+      INCLUDE_DIRS ${INCLUDE_DIRS}
+      DEFINITIONS ${COMPILER_DEFINITIONS}
+    )
+endif ()
diff --git a/ctrl/facemgr/src/cache.c b/ctrl/facemgr/src/cache.c
new file mode 100644
index 000000000..f994d7d37
--- /dev/null
+++ b/ctrl/facemgr/src/cache.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file cache.c
+ * \brief Implementation of face cache.
+ *
+ * The cache is currently implemented as a list so as not to worry about
+ * platform-specific implementations (eg missing functions in BSD libC for
+ * search.h).
+ */
+
+#include <math.h> // log2
+#include <string.h> // memmove
+
+#include "cache.h"
+
+#define FACE_CACHE_MAX_SIZE_LOG_INIT 0
+
+face_cache_t *
+face_cache_create()
+{
+    face_cache_t * face_cache = malloc(sizeof(face_cache_t));
+    if (!face_cache)
+        goto ERR_MALLOC;
+
+    face_cache->max_size_log = FACE_CACHE_MAX_SIZE_LOG_INIT;
+#if(FACE_CACHE_MAX_SIZE_LOG_INIT == 0)
+    face_cache->faces = NULL;
+#else
+    face_cache->faces = malloc((1 << face_cache->max_size_log) * sizeof(face_t*));
+    if (!face_cache->faces)
+        goto ERR_ARRAY:
+#endif
+    face_cache->size = 0;
+
+    return face_cache;
+
+#if(FACE_CACHE_MAX_SIZE_LOG_INIT != 0)
+ERR_ARRAY:
+    free(face_cache);
+#endif
+ERR_MALLOC:
+    return NULL;
+}
+
+void
+face_cache_free(face_cache_t * face_cache)
+{
+    free(face_cache->faces);
+
+    free(face_cache);
+}
+
+face_t *
+face_cache_add(face_cache_t * face_cache, face_t * face)
+{
+    /* Ensure sufficient space for next addition */
+    size_t new_size_log = (face_cache->size > 0) ? log2(face_cache->size) + 1 : 0;
+    if (new_size_log > face_cache->max_size_log) {
+        face_cache->max_size_log = new_size_log;
+        face_cache->faces = realloc(face_cache->faces, (1 << new_size_log) * sizeof(face_t*));
+    }
+
+    if (!face_cache->faces)
+        goto ERR_REALLOC;
+
+    face_cache->faces[face_cache->size++] = face;
+
+    return face;
+
+ERR_REALLOC:
+    return NULL;
+}
+
+int face_cache_search(face_cache_t * face_cache, face_t * face, face_cmp_t face_cmp)
+{
+    for (int i = 0; i < face_cache->size; i++)
+        if (face_cmp(face, face_cache->faces[i]))
+            return i;
+    return -1;
+}
+
+/* Remove a single occurrence */
+face_t *
+face_cache_remove(face_cache_t * face_cache, face_t * face)
+{
+    int pos = face_cache_search(face_cache, face, face_cmp);
+    if (pos < 0)
+        return NULL;
+
+    /* No need to move memory if last item is removed */
+    if (pos < face_cache->size)
+        memmove(face_cache->faces+pos, face_cache->faces+pos+1, face_cache->size - pos);
+
+    face_cache->size--;
+
+    return face;
+}
+
+/* TODO : remove by ... */
+
+face_t *
+face_cache_get_by_id(face_cache_t * face_cache, int id)
+{
+    return NULL;
+}
+
+
+
+void
+face_cache_dump(face_cache_t * face_cache)
+{
+
+}
diff --git a/ctrl/facemgr/src/cache.h b/ctrl/facemgr/src/cache.h
new file mode 100644
index 000000000..1389ed6ec
--- /dev/null
+++ b/ctrl/facemgr/src/cache.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file state.h
+ * \brief Face cache
+ *
+ * The face cache is an index array of faces that mirror the current state of
+ * the forwarder in order to filter out redundant events, and perform set
+ * reconciliation.
+ */
+#ifndef FACEMGR_CACHE_H
+#define FACEMGR_CACHE_H
+
+#include <stdlib.h>
+
+#include "face.h"
+
+/**
+ * \brief Face cache
+ */
+typedef struct {
+    face_t ** faces;     /**< array of _pointers_ to faces */
+    size_t max_size_log; /**< log2 of allocated size */
+    size_t size;         /**< effective array size */
+} face_cache_t;
+
+face_cache_t * face_cache_create();
+void face_cache_free(face_cache_t * face_cache);
+
+/* a la VPP vector, we never create a face outside of the vector */
+/* problem is that face ptr can get invalid if we manipulate the vector */
+face_t * face_cache_get(face_cache_t * cache_cache);
+
+face_t * face_cache_add(face_cache_t * face_cache, face_t * face);
+face_t * face_cache_remove(face_cache_t * face_cache, face_t * face);
+face_t * face_cache_get_by_id(face_cache_t * face_cache, int id);
+
+void face_cache_dump(face_cache_t * face_cache);
+
+#endif /* FACEMGR_CACHE_H */
diff --git a/ctrl/facemgr/src/common.h b/ctrl/facemgr/src/common.h
new file mode 100644
index 000000000..a73964b6d
--- /dev/null
+++ b/ctrl/facemgr/src/common.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file common.h
+ * \file Common definitions used throughout the code
+ */
+#ifndef FACEMGR_COMMON_H
+#define FACEMGR_COMMON_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "util/types.h"
+#include "util/ip_address.h"
+#include "util/token.h" // XXX debug
+
+//#define DEBUG
+
+/* Return value conventions */
+#define FACEMGR_SUCCESS 0
+#define FACEMGR_FAILURE -1
+#define FACEMGR_IS_ERROR(rc) (rc < 0)
+
+/* Useful types and macros for comparisons */
+typedef int(*cmp_t)(const void * x, const void * y);
+
+#define INT_CMP(x, y) x < y ? -1 : (x == y ? 0 : 1)
+
+/* Dump with indent */
+#define INDENT(n, fmt) "%*s" fmt, n, ""
+#define printfi(n, fmt, ...) printf(INDENT(n*4, fmt), ##__VA_ARGS__)
+
+/* Boilerplate code */
+
+#define NO_INITIALIZE(NAME)                                             \
+int                                                                     \
+NAME ## _initialize(NAME ## _t * obj) {                                 \
+    return FACEMGR_SUCCESS;                                             \
+}
+
+#define NO_FINALIZE(NAME)                                               \
+int                                                                     \
+NAME ## _finalize(NAME ## _t * obj) {                                   \
+    return FACEMGR_SUCCESS;                                             \
+}
+
+#define AUTOGENERATE_CREATE_FREE(NAME)                                  \
+                                                                        \
+NAME ## _t *                                                            \
+NAME ## _create()                                                       \
+{                                                                       \
+    NAME ## _t * obj  = malloc(sizeof(NAME ## _t));                     \
+    if (!obj)                                                           \
+        goto ERR_MALLOC;                                                \
+                                                                        \
+    if (FACEMGR_IS_ERROR(NAME ## _initialize(obj)))                     \
+        goto ERR_INIT;                                                  \
+                                                                        \
+    return obj;                                                         \
+                                                                        \
+ERR_INIT:                                                               \
+    free(obj);                                                          \
+ERR_MALLOC:                                                             \
+    return NULL;                                                        \
+}                                                                       \
+                                                                        \
+void                                                                    \
+NAME ## _free(NAME ## _t * obj)                                         \
+{                                                                       \
+    if (FACEMGR_IS_ERROR(NAME ## _finalize(obj)))                       \
+        (void)0; /* XXX */                                              \
+    free(obj);                                                          \
+}                                                                       \
+
+#define AUTOGENERATE_DEFS(NAME)                                         \
+int NAME ## _initialize(NAME ## _t *);                                  \
+int NAME ## _finalize(NAME ## _t *);                                    \
+NAME ## _t * NAME ## _create();                                         \
+void NAME ## _free(NAME ## _t *);                                       \
+
+#endif /* FACEMGR_COMMON_H */
diff --git a/ctrl/facemgr/src/error.c b/ctrl/facemgr/src/error.c
new file mode 100644
index 000000000..4dcea6e1f
--- /dev/null
+++ b/ctrl/facemgr/src/error.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * @file error.c
+ * @brief Implementation of error management functions.
+ */
+
+#include "error.h"
+
+const char *FACEMGR_ERROR_STRING[] = {
+#define _(a,b,c) [b] = c,
+  foreach_facemgr_error
+#undef _
+};
+
diff --git a/ctrl/facemgr/src/error.h b/ctrl/facemgr/src/error.h
new file mode 100644
index 000000000..a0d76b3e5
--- /dev/null
+++ b/ctrl/facemgr/src/error.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FACEMGR_ERROR_H
+#define FACEMGR_ERROR_H
+
+#define foreach_facemgr_error                           \
+_(NONE,         0,      "OK")                           \
+
+
+typedef enum {
+#define _(a,b,c) FACEMGR_ERROR_##a = (-b),
+    foreach_facemgr_error
+#undef _
+    FACEMGR_ERROR_N,
+} facemgr_error_t;
+
+extern const char *HICN_LIB_ERROR_STRING[];
+
+#define hicn_strerror(errno) (char *)(HICN_LIB_ERROR_STRING[-errno])
+
+#endif /* FACEMGR_ERROR_H */
diff --git a/ctrl/facemgr/src/event.c b/ctrl/facemgr/src/event.c
new file mode 100644
index 000000000..446c51c22
--- /dev/null
+++ b/ctrl/facemgr/src/event.c
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file event.h
+ * \brief Implementatino of face events
+ */
+
+#include "common.h"
+#include "event.h"
+#include "interface.h"
+#include "util/token.h"
+
+const char * event_type_str[] = {
+#define _(x) [EVENT_TYPE_ ## x] = STRINGIZE(x),
+foreach_event_type
+#undef _
+};
+
+int
+event_raise(event_type_t type, const face_t * face, const interface_t * interface)
+{
+    event_t event = { .type = type, .face = face };
+    if (interface->callback)
+        interface->callback(interface->callback_data, &event);
+    return FACEMGR_SUCCESS;
+}
diff --git a/ctrl/facemgr/src/event.h b/ctrl/facemgr/src/event.h
new file mode 100644
index 000000000..53295d009
--- /dev/null
+++ b/ctrl/facemgr/src/event.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file event.h
+ * \brief Face event
+ */
+#ifndef FACEMGR_EVENT_H
+#define FACEMGR_EVENT_H
+
+#include "face.h"
+#include "interface.h"
+
+#define foreach_event_type      \
+    _(UNDEFINED)                \
+    _(CREATE)                   \
+    _(UPDATE)                   \
+    _(DELETE)                   \
+    _(SET_PARAMS)               \
+    _(SET_UP)                   \
+    _(SET_DOWN)                 \
+    _(SET_TAGS)                 \
+    _(CLEAR_TAGS)               \
+    _(ADD_TAG)                  \
+    _(REMOVE_TAG)               \
+    _(N)
+
+#define MAXSZ_EVENT_TYPE_ 10
+#define MAXSZ_EVENT_TYPE MAXSZ_EVENT_TYPE_ + 1
+
+typedef enum {
+#define _(x) EVENT_TYPE_ ## x,
+foreach_event_type
+#undef _
+} event_type_t;
+
+extern const char * event_type_str[];
+
+typedef struct event_s {
+    event_type_t type;
+    const face_t * face; /* + bitfield for face fields ? */
+} event_t;
+
+int
+event_raise(event_type_t type, const face_t * face, const interface_t * interface);
+
+#endif /* FACEMGR_EVENT_H */
diff --git a/ctrl/facemgr/src/face.c b/ctrl/facemgr/src/face.c
new file mode 100644
index 000000000..7da255049
--- /dev/null
+++ b/ctrl/facemgr/src/face.c
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file face.c
+ * \brief Implementation of face abstraction
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "face.h"
+#include "util/hash.h"
+#include "util/token.h"
+
+#define member_size(type, member) sizeof(((type *)0)->member)
+
+
+/* Netdevice */
+
+const char * netdevice_type_str[] = {
+#define _(x) [NETDEVICE_TYPE_ ## x] = STRINGIZE(x),
+foreach_netdevice_type
+#undef _
+};
+
+
+/* Face state */
+
+const char * face_state_str[] = {
+#define _(x) [FACE_STATE_ ## x] = STRINGIZE(x),
+foreach_face_state
+#undef _
+};
+
+
+/* Face type */
+
+const char * face_type_str[] = {
+#define _(x) [FACE_TYPE_ ## x] = STRINGIZE(x),
+foreach_face_type
+#undef _
+};
+
+
+/* Face */
+
+int
+face_initialize(face_t * face)
+{
+    bzero(face, sizeof(face_t)); /* 0'ed for hash */
+    return 1;
+}
+
+int
+face_initialize_udp(face_t * face, const ip_address_t * local_addr,
+        u16 local_port, const ip_address_t * remote_addr, u16 remote_port,
+        int family)
+{
+    if (!local_addr)
+        return -1;
+
+    *face = (face_t) {
+        .type = FACE_TYPE_UDP,
+        .params.tunnel = {
+            .family = family,
+            .local_addr = *local_addr,
+            .local_port = local_port,
+            .remote_addr = remote_addr ? *remote_addr : IP_ADDRESS_EMPTY,
+            .remote_port = remote_port,
+        },
+    };
+    return 1;
+}
+
+int
+face_initialize_udp_sa(face_t * face, const struct sockaddr * local_addr,
+        const struct sockaddr * remote_addr)
+{
+    if (!local_addr)
+        return -1;
+
+    if (remote_addr && (local_addr->sa_family != remote_addr->sa_family))
+        return -1;
+
+    switch (local_addr->sa_family) {
+        case AF_INET:
+            {
+            struct sockaddr_in *lsai = (struct sockaddr_in *)local_addr;
+            struct sockaddr_in *rsai = (struct sockaddr_in *)remote_addr;
+            *face = (face_t) {
+                .type = FACE_TYPE_UDP,
+                .params.tunnel = {
+                    .family = AF_INET,
+                    .local_addr.v4.as_inaddr = lsai->sin_addr,
+                    .local_port = lsai ? ntohs(lsai->sin_port) : 0,
+                    .remote_addr = IP_ADDRESS_EMPTY,
+                    .remote_port = rsai ? ntohs(rsai->sin_port) : 0,
+                },
+            };
+            if (rsai)
+                face->params.tunnel.remote_addr.v4.as_inaddr = rsai->sin_addr;
+            }
+            break;
+        case AF_INET6:
+            {
+            struct sockaddr_in6 *lsai = (struct sockaddr_in6 *)local_addr;
+            struct sockaddr_in6 *rsai = (struct sockaddr_in6 *)remote_addr;
+            *face = (face_t) {
+                .type = FACE_TYPE_UDP,
+                .params.tunnel = {
+                    .family = AF_INET6,
+                    .local_addr.v6.as_in6addr = lsai->sin6_addr,
+                    .local_port = lsai ? ntohs(lsai->sin6_port) : 0,
+                    .remote_addr = IP_ADDRESS_EMPTY,
+                    .remote_port = rsai ? ntohs(rsai->sin6_port) : 0,
+                },
+            };
+            if (rsai)
+                face->params.tunnel.remote_addr.v6.as_in6addr = rsai->sin6_addr;
+            }
+            break;
+        default:
+            return -1;
+    }
+    return 1;
+}
+
+face_t * face_create()
+{
+    face_t * face = calloc(1, sizeof(face_t)); /* 0'ed for hash */
+    return face;
+}
+
+face_t * face_create_udp(const ip_address_t * local_addr, u16 local_port,
+        const ip_address_t * remote_addr, u16 remote_port, int family)
+{
+    face_t * face = face_create();
+    if (face_initialize_udp(face, local_addr, local_port, remote_addr, remote_port, family) < 0)
+        goto ERR_INIT;
+    return face;
+
+ERR_INIT:
+    free(face);
+    return NULL;
+}
+
+face_t * face_create_udp_sa(const struct sockaddr * local_addr,
+        const struct sockaddr * remote_addr)
+{
+    face_t * face = face_create();
+    if (face_initialize_udp_sa(face, local_addr, remote_addr) < 0)
+        goto ERR_INIT;
+    return face;
+
+ERR_INIT:
+    free(face);
+    return NULL;
+}
+
+void face_free(face_t * face)
+{
+    free(face);
+}
+
+#define face_param_cmp(f1, f2, face_param_type)            \
+    memcmp(&f1->type, &f2->type,  \
+            member_size(face_params_t, face_param_type));
+
+/**
+ * \brief Compare two faces
+ * \param [in] f1 - First face
+ * \param [in] f2 - Second face
+ * \return whether faces are equal, ie both their types are parameters are
+ * equal.
+ *
+ * NOTE: this function implements a partial order.
+ */
+int
+face_cmp(const face_t * f1, const face_t * f2)
+{
+    if (f1->type != f2->type)
+        return false;
+
+    switch(f1->type) {
+        case FACE_TYPE_HICN:
+            return face_param_cmp(f1, f2, hicn);
+        case FACE_TYPE_TCP:
+        case FACE_TYPE_UDP:
+            return face_param_cmp(f1, f2, tunnel);
+        default:
+            return false;
+    }
+}
+
+hash_t
+face_hash(const face_t * face)
+{
+    /* Assuming the unused part of the struct is set to zero */
+    return hash_struct(face);
+}
+
+/* /!\ Please update constants in header file upon changes */
+size_t
+face_snprintf(char * s, size_t size, const face_t * face)
+{
+    switch(face->type) {
+        case FACE_TYPE_HICN:
+            return 0; // XXX Not implemented
+        case FACE_TYPE_TCP:
+        case FACE_TYPE_UDP:
+            {
+                char local[MAXSZ_IP_ADDRESS];
+                char remote[MAXSZ_IP_ADDRESS];
+                char tags[MAXSZ_POLICY_TAGS];
+
+                ip_address_snprintf(local, MAXSZ_IP_ADDRESS,
+                        &face->params.tunnel.local_addr,
+                        face->params.tunnel.family);
+                ip_address_snprintf(remote, MAXSZ_IP_ADDRESS,
+                        &face->params.tunnel.remote_addr,
+                        face->params.tunnel.family);
+                policy_tags_snprintf(tags, MAXSZ_POLICY_TAGS, face->tags);
+
+                return snprintf(s, size, "%s [%s:%d -> %s:%d] [%s]",
+                        face_type_str[face->type],
+                        local,
+                        face->params.tunnel.local_port,
+                        remote,
+                        face->params.tunnel.remote_port,
+                        tags);
+            }
+            break;
+        default:
+            return 0;
+    }
+
+}
+
+int
+face_set_tags(face_t * face, policy_tags_t tags)
+{
+    face->tags = tags;
+    return 1;
+}
diff --git a/ctrl/facemgr/src/face.h b/ctrl/facemgr/src/face.h
new file mode 100644
index 000000000..8b553f685
--- /dev/null
+++ b/ctrl/facemgr/src/face.h
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file face.h
+ * \brief Face abstraction
+ */
+#ifndef HICN_FACE_H
+#define HICN_FACE_H
+
+#ifndef SPACES
+#define SPACES(x) x
+#endif
+#ifndef SPACE
+#define SPACE 1
+#endif
+#ifndef NULLTERM
+#define NULLTERM 1
+#endif
+
+#include "util/ip_address.h"
+#include "util/policy.h"
+#include "util/types.h"
+
+
+/* Netdevice type */
+
+#include <net/if.h> // IFNAMSIZ
+
+#define foreach_netdevice_type  \
+    _(UNDEFINED)                \
+    _(WIRED)                    \
+    _(WIFI)                     \
+    _(CELLULAR)                 \
+    _(VPN)                      \
+    _(N)
+
+#define MAXSZ_NETDEVICE_TYPE_ 9
+#define MAXSZ_NETDEVICE_TYPE MAXSZ_NETDEVICE_TYPE_ + NULLTERM
+
+typedef enum {
+#define _(x) NETDEVICE_TYPE_ ## x,
+foreach_netdevice_type
+#undef _
+} netdevice_type_t;
+
+extern const char * netdevice_type_str[];
+
+
+/* Netdevice */
+
+typedef struct {
+    u32 index;
+    char name[IFNAMSIZ];
+} netdevice_t;
+
+#define NETDEVICE_UNDEFINED_INDEX 0
+
+/* Face state */
+
+#define foreach_face_state      \
+    _(UNDEFINED)                \
+    _(PENDING_UP)               \
+    _(UP)                       \
+    _(PENDING_DOWN)             \
+    _(DOWN)                     \
+    _(ERROR)                    \
+    _(N)
+
+#define MAXSZ_FACE_STATE_ 12
+#define MAXSZ_FACE_STATE MAXSZ_FACE_STATE_ + 1
+
+typedef enum {
+#define _(x) FACE_STATE_ ## x,
+foreach_face_state
+#undef _
+} face_state_t;
+
+extern const char * face_state_str[];
+
+
+/* Face type */
+
+#define foreach_face_type       \
+    _(UNDEFINED)                \
+    _(HICN)                     \
+    _(HICN_LISTENER)            \
+    _(TCP)                      \
+    _(TCP_LISTENER)             \
+    _(UDP)                      \
+    _(UDP_LISTENER)             \
+    _(N)
+
+#define MAXSZ_FACE_TYPE_ 13
+#define MAXSZ_FACE_TYPE MAXSZ_FACE_TYPE_  + 1
+
+typedef enum {
+#define _(x) FACE_TYPE_ ## x,
+foreach_face_type
+#undef _
+} face_type_t;
+
+extern const char * face_type_str[];
+
+#define MAXSZ_FACE_ MAXSZ_FACE_TYPE_ + 2 * MAXSZ_IP_ADDRESS_ + 2 * MAXSZ_PORT_ + 9 + MAXSZ_POLICY_TAGS_
+#define MAXSZ_FACE MAXSZ_FACE_ + 1
+
+/* Face */
+
+typedef union {
+    int family; /* To access family independently of face type */
+    struct {
+        int family;
+        netdevice_t netdevice;
+        ip_address_t local_addr;
+        ip_address_t remote_addr;
+    } hicn;
+    struct {
+        int family;
+        ip_address_t local_addr;
+        u16 local_port;
+        ip_address_t remote_addr;
+        u16 remote_port;
+    } tunnel;
+} face_params_t;
+
+typedef struct {
+    face_type_t type;
+    face_params_t params;
+    face_state_t admin_state;
+    face_state_t state;
+#ifdef WITH_POLICY
+    policy_tags_t tags; /**< \see policy_tag_t */
+#endif /* WITH_POLICY */
+} face_t;
+
+int face_initialize(face_t * face);
+int face_initialize_udp(face_t * face, const ip_address_t * local_addr,
+        u16 local_port, const ip_address_t * remote_addr, u16 remote_port,
+        int family);
+int face_initialize_udp_sa(face_t * face,
+        const struct sockaddr * local_addr, const struct sockaddr * remote_addr);
+
+face_t * face_create();
+face_t * face_create_udp(const ip_address_t * local_addr, u16 local_port,
+        const ip_address_t * remote_addr, u16 remote_port, int family);
+face_t * face_create_udp_sa(const struct sockaddr * local_addr,
+        const struct sockaddr * remote_addr);
+
+int face_finalize(face_t * face);
+
+void face_free(face_t * face);
+
+typedef int (*face_cmp_t)(const face_t * f1, const face_t * f2);
+
+int face_cmp(const face_t * f1, const face_t * f2);
+hash_t face_hash(const face_t * face);
+
+size_t
+face_snprintf(char * s, size_t size, const face_t * face);
+
+int face_set_tags(face_t * face, policy_tags_t tags);
+
+#endif /* HICN_FACE_H */
+
diff --git a/ctrl/facemgr/src/face_cache.c b/ctrl/facemgr/src/face_cache.c
new file mode 100644
index 000000000..bee36af30
--- /dev/null
+++ b/ctrl/facemgr/src/face_cache.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2017-2019 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 "face_cache.h"
+
+#include "face.h"
+#include "util/set.h"
+
+TYPEDEF_SET(face_cache, face_t *, face_cmp, face_snprintf);
diff --git a/ctrl/facemgr/src/face_cache.h b/ctrl/facemgr/src/face_cache.h
new file mode 100644
index 000000000..caefb7e22
--- /dev/null
+++ b/ctrl/facemgr/src/face_cache.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FACE_CACHE_H
+#define FACE_CACHE_H
+
+#include "face.h"
+#include "util/set.h"
+
+TYPEDEF_SET_H(face_cache, face_t *);
+
+#endif /* FACE_CACHE_H */
diff --git a/ctrl/facemgr/src/face_rules.c b/ctrl/facemgr/src/face_rules.c
new file mode 100644
index 000000000..ddefc15f9
--- /dev/null
+++ b/ctrl/facemgr/src/face_rules.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2017-2019 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 "face_rules.h"
+
+#include <string.h>
+#include "util/policy.h"
+
+TYPEDEF_MAP(face_rules, const char *, policy_tags_t, strcmp, string_snprintf, policy_tags_snprintf);
diff --git a/ctrl/facemgr/src/face_rules.h b/ctrl/facemgr/src/face_rules.h
new file mode 100644
index 000000000..28f5391a0
--- /dev/null
+++ b/ctrl/facemgr/src/face_rules.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FACE_RULES_H
+#define FACE_RULES_H
+
+#include "util/map.h"
+#include "util/policy.h"
+
+/*
+ * Face creation rules
+ *
+ * For now, face creations rules are very simple and consist in a map between
+ * the physical interface name, and the associated list of tags that will
+ * preempt those assigned by the system.
+ */
+TYPEDEF_MAP_H(face_rules, const char *, policy_tags_t);
+
+#endif /* FACE_RULES_H */
diff --git a/ctrl/facemgr/src/facemgr.c b/ctrl/facemgr/src/facemgr.c
new file mode 100644
index 000000000..41e30de56
--- /dev/null
+++ b/ctrl/facemgr/src/facemgr.c
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file facemgr.c
+ * \brief Implementation of Face manager library interface
+ */
+
+#include <stdio.h>
+
+#include "common.h"
+#include "event.h"
+#include "facemgr.h"
+#include "interface.h"
+#include "util/log.h"
+
+#ifdef __APPLE__
+extern interface_ops_t network_framework_ops;
+#endif
+#ifdef __linux__
+extern interface_ops_t netlink_ops;
+#endif
+#if 0
+extern interface_ops_t dummy_ops;
+#endif
+extern interface_ops_t hicn_light_ops;
+
+int
+facemgr_initialize(facemgr_t * facemgr)
+{
+    int rc;
+
+    rc = interface_map_initialize(&facemgr->interface_map);
+    if (FACEMGR_IS_ERROR(rc))
+        goto ERR_INTERFACE_MAP;
+
+    rc = face_cache_initialize(&facemgr->face_cache);
+    if (FACEMGR_IS_ERROR(rc))
+        goto ERR_FACE_SET;
+
+    rc = face_rules_initialize(&facemgr->rules);
+    if (FACEMGR_IS_ERROR(rc))
+        goto ERR_FACE_SET;
+
+    return FACEMGR_SUCCESS;
+
+ERR_FACE_SET:
+    interface_map_finalize(&facemgr->interface_map);
+
+ERR_INTERFACE_MAP:
+    return FACEMGR_FAILURE;
+}
+
+int
+facemgr_finalize(facemgr_t * facemgr)
+{
+    int rc;
+
+    /* XXX Free all interfaces: pass free to map */
+    rc = interface_map_finalize(&facemgr->interface_map);
+    if (FACEMGR_IS_ERROR(rc))
+        goto ERR;
+
+    rc = face_cache_finalize(&facemgr->face_cache);
+    if (FACEMGR_IS_ERROR(rc))
+        goto ERR;
+
+    rc = face_rules_finalize(&facemgr->rules);
+    if (FACEMGR_IS_ERROR(rc))
+        goto ERR;
+
+    return FACEMGR_SUCCESS;
+
+ERR:
+    return FACEMGR_FAILURE;
+}
+
+AUTOGENERATE_CREATE_FREE(facemgr);
+
+int
+facemgr_on_event(facemgr_t * facemgr, event_t * event)
+{
+    int rc;
+    char face_s[MAXSZ_FACE];
+    face_t * cached_face;
+
+    if (!event->face) {
+        printf("Event with empty face\n");
+        return -1;
+    }
+
+    face_t face = *event->face;
+
+    /* Complement unbound UDP faces */
+    switch(face.type) {
+        case FACE_TYPE_TCP:
+        case FACE_TYPE_UDP:
+            switch (face.params.tunnel.family) {
+                case AF_INET:
+                    if ((ip_address_empty(&face.params.tunnel.remote_addr)) &&
+                            (!ip_address_empty(&facemgr->overlay_v4_remote_addr)))
+                        face.params.tunnel.remote_addr = facemgr->overlay_v4_remote_addr;
+                    if ((face.params.tunnel.local_port == 0) && (facemgr->overlay_v4_local_port != 0))
+                        face.params.tunnel.local_port = facemgr->overlay_v4_local_port;
+                    if ((face.params.tunnel.remote_port == 0) && (facemgr->overlay_v4_remote_port != 0))
+                        face.params.tunnel.remote_port = facemgr->overlay_v4_remote_port;
+                    break;
+                case AF_INET6:
+                    if ((ip_address_empty(&face.params.tunnel.remote_addr)) &&
+                            (!ip_address_empty(&facemgr->overlay_v6_remote_addr)))
+                        face.params.tunnel.remote_addr = facemgr->overlay_v6_remote_addr;
+                    if ((face.params.tunnel.local_port == 0) && (facemgr->overlay_v6_local_port != 0))
+                        face.params.tunnel.local_port = facemgr->overlay_v6_local_port;
+                    if ((face.params.tunnel.remote_port == 0) && (facemgr->overlay_v6_remote_port != 0))
+                        face.params.tunnel.remote_port = facemgr->overlay_v6_remote_port;
+                default:
+                    break;
+            }
+            break;
+        default:
+            break;
+    }
+
+    face_snprintf(face_s, MAXSZ_FACE, &face);
+
+    /* TODO Here, we need to filter events based on our cache, and update the cache
+     * based on our actions if they are successful */
+
+    switch(event->type) {
+        case EVENT_TYPE_CREATE:
+            rc = face_cache_get(&facemgr->face_cache, &face, &cached_face);
+            if (!FACEMGR_IS_ERROR(rc)) {
+                DEBUG("Face found in cache");
+                goto IGNORE_EVENT;
+            }
+            rc = face_cache_add(&facemgr->face_cache, &face);
+            if (FACEMGR_IS_ERROR(rc))
+                WARN("Failed to add face to cache");
+            break;
+        case EVENT_TYPE_DELETE:
+            rc = face_cache_remove(&facemgr->face_cache, &face, &cached_face);
+            if (FACEMGR_IS_ERROR(rc))
+                WARN("Face not found in cache");
+            break;
+        case EVENT_TYPE_SET_UP:
+        case EVENT_TYPE_SET_DOWN:
+            /* TODO We need a return code to update the cache */
+            break;
+        default:
+            printf("Not implemented!\n");
+            break;
+    }
+
+    /* Process event */
+    printf("[ FACE %s ] %s\n", event_type_str[event->type], face_s);
+    /* Hardcoded hicn-light */
+    rc = interface_on_event(facemgr->hl, event);
+    if (FACEMGR_IS_ERROR(rc))
+        goto ERR;
+
+IGNORE_EVENT:
+    return FACEMGR_SUCCESS;
+
+ERR:
+    return FACEMGR_FAILURE;
+}
+
+#ifdef __linux__
+void interface_callback(evutil_socket_t fd, short what, void * arg) {
+    interface_t * interface = (interface_t *)arg;
+    interface->ops->callback(interface);
+}
+#endif /* __linux__ */
+
+int
+facemgr_create_interface(facemgr_t * facemgr, const char * name, const char * type, interface_t ** interface)
+{
+    int fd, rc;
+
+    INFO("Creating interface %s [%s]...\n", name, type);
+    *interface = interface_create(name, type);
+    if (!*interface) {
+        ERROR("Error creating interface %s [%s]\n", name, type);
+        return -1;
+    }
+    interface_set_callback(*interface, facemgr_on_event, facemgr);
+
+    fd = interface_initialize(*interface, &facemgr->rules);
+    if (fd < 0)
+        return -2;
+    if (fd != 0) {
+#ifdef __linux__
+        evutil_make_socket_nonblocking(fd);
+        struct event * event = event_new(facemgr->loop, fd, EV_READ | EV_PERSIST, interface_callback, *interface);
+        if (!event) {
+            return -3;
+        }
+
+        if (event_add(event, NULL) < 0) {
+            return -4;
+        }
+#else
+        ERROR("Not implemented\n");
+        return FACEMGR_FAILURE;
+#endif /* __linux__ */
+    }
+
+    rc = interface_map_add(&facemgr->interface_map, (*interface)->name, *interface);
+    if (FACEMGR_IS_ERROR(rc))
+        return -5;
+
+    DEBUG("Interface created successfully.\n");
+    return FACEMGR_SUCCESS;
+}
+
+int
+facemgr_bootstrap(facemgr_t * facemgr)
+{
+    int rc;
+
+    DEBUG("Registering interfaces...");
+    rc = interface_register(&hicn_light_ops);
+    if (FACEMGR_IS_ERROR(rc)) {
+        ERROR("Could not register interfaces");
+        goto ERR_REGISTER;
+    }
+
+#ifdef __APPLE__
+    rc = interface_register(&network_framework_ops);
+    if (FACEMGR_IS_ERROR(rc))
+        goto ERR_REGISTER;
+#endif /* __APPLE__ */
+
+#ifdef __linux__
+    rc = interface_register(&netlink_ops);
+    if (FACEMGR_IS_ERROR(rc))
+        goto ERR_REGISTER;
+#endif /* __linux__ */
+
+#if 0
+    rc = interface_register(&dummy_ops);
+    if (FACEMGR_IS_ERROR(rc))
+        goto ERR_REGISTER;
+#endif
+
+    rc = facemgr_create_interface(facemgr, "hl", "hicn_light", &facemgr->hl);
+    if (rc < 0) {
+        ERROR("Error creating 'hICN forwarder (hicn-light)' interface\n");
+        goto ERR_HL_CREATE;
+    }
+
+#ifdef __APPLE__
+    rc = facemgr_create_interface(facemgr, "nf", "network_framework", &facemgr->nf);
+    if (rc < 0) {
+        ERROR("Error creating 'Apple Network Framework' interface\n");
+        goto ERR_NF_CREATE;
+    }
+#endif /* __APPLE__ */
+
+#ifdef __linux__
+    rc = facemgr_create_interface(facemgr, "nl", "netlink", &facemgr->nl);
+    if (rc < 0) {
+        ERROR("Error creating 'Netlink' interface\n");
+        goto ERR_NF_CREATE;
+    }
+#endif /* __linux__ */
+
+#if 0
+    rc = facemgr_create_interface(facemgr, "dummy", "dummy", &facemgr->dummy);
+    if (rc < 0) {
+        ERROR("Error creating 'Dummy' interface\n");
+        goto ERR_NF_CREATE;
+    }
+#endif
+
+    DEBUG("Facemgr successfully initialized...");
+
+    return FACEMGR_SUCCESS;
+
+ERR_NF_CREATE:
+    interface_free(facemgr->hl);
+ERR_HL_CREATE:
+    //interface_map_remove(&facemgr->interface_map, data->nf->name);
+ERR_REGISTER:
+    return FACEMGR_FAILURE;
+}
diff --git a/ctrl/facemgr/src/facemgr.h b/ctrl/facemgr/src/facemgr.h
new file mode 100644
index 000000000..6505a1bd8
--- /dev/null
+++ b/ctrl/facemgr/src/facemgr.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file facemgr.h
+ * \brief Face manager library interface
+ */
+#ifndef FACEMGR_H
+#define FACEMGR_H
+
+#include <string.h>
+#include "common.h"
+#include "face.h"
+#include "face_cache.h"
+#include "face_rules.h"
+#include "interface.h"
+#include "interface_map.h"
+#include "util/ip_address.h"
+#include "util/map.h"
+#include "util/policy.h"
+#ifndef __APPLE__
+#include <event2/event.h>
+#endif /* __APPLE__ */
+
+/*
+ * \brief Face manager context
+ */
+typedef struct {
+#ifndef APPLE
+    /* Event loop */
+    struct event_base * loop;
+#endif /* APPLE */
+
+    interface_map_t interface_map;
+    interface_t * hl;
+
+#ifdef __APPLE__
+    interface_t * nf;
+#endif /* __APPLE__ */
+
+#ifdef __linux__
+    interface_t * nl;
+#endif /* __linux__ */
+
+#if 0
+    interface_t * dummy;
+#endif
+
+    /* Overlay management */
+    uint16_t overlay_v4_local_port;
+    ip_address_t overlay_v4_remote_addr;
+    uint16_t overlay_v4_remote_port;
+    uint16_t overlay_v6_local_port;
+    ip_address_t overlay_v6_remote_addr;
+    uint16_t overlay_v6_remote_port;
+
+    face_rules_t rules;
+    face_cache_t face_cache;
+} facemgr_t;
+
+AUTOGENERATE_DEFS(facemgr);
+
+int facemgr_bootstrap(facemgr_t * facemgr);
+
+#endif /* FACEMGR_H */
diff --git a/ctrl/facemgr/src/interface.c b/ctrl/facemgr/src/interface.c
new file mode 100644
index 000000000..af9f666a7
--- /dev/null
+++ b/ctrl/facemgr/src/interface.c
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file interface.c
+ * \brief Implementation of interface base class.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include "event.h"
+#include "face_rules.h"
+#include "interface.h"
+#include "interface_ops_map.h"
+#include "util/map.h"
+
+static interface_ops_map_t * interface_ops_map = NULL;
+
+int
+interface_register(const interface_ops_t * ops)
+{
+    if (!interface_ops_map) {
+        interface_ops_map = interface_ops_map_create();
+        if (!interface_ops_map)
+            return FACEMGR_FAILURE;
+    }
+    interface_ops_map_add(interface_ops_map, ops->type, ops);
+    return FACEMGR_SUCCESS;
+}
+
+interface_t *
+interface_create(const char * name, const char * type)
+{
+
+    interface_ops_t * ops;
+    int rc = interface_ops_map_get(interface_ops_map, type, &ops);
+    if (FACEMGR_IS_ERROR(rc)) {
+        printf("Interface type not found %s\n", type);
+        return NULL;
+    }
+
+    interface_t * interface = malloc(sizeof(interface_t));
+    if (!interface)
+        return NULL;
+
+    interface->name = strdup(name);
+    /* this should use type */
+    interface->ops = ops;
+    interface->callback = NULL;
+    interface->callback_data = NULL;
+    interface->data = NULL;
+
+    return interface;
+}
+
+void
+interface_free(interface_t * interface)
+{
+    free(interface->name);
+    free(interface);
+}
+
+void
+_interface_set_callback(interface_t * interface, callback_t callback, void * callback_data)
+{
+    interface->callback = callback;
+    interface->callback_data = callback_data;
+}
+
+int
+interface_initialize(interface_t * interface, struct face_rules_s * rules)
+{
+    if (!interface->ops->initialize)
+        return FACEMGR_FAILURE;
+    return interface->ops->initialize(interface, rules, &interface->data);
+}
+
+int
+interface_finalize(interface_t * interface)
+{
+    if (!interface->ops->finalize)
+        return FACEMGR_FAILURE;
+    return interface->ops->finalize(interface);
+}
+
+int
+interface_on_event(interface_t * interface, const event_t * event)
+{
+    if (!interface->ops->on_event)
+        return FACEMGR_FAILURE;
+    return interface->ops->on_event(interface, event);
+}
diff --git a/ctrl/facemgr/src/interface.h b/ctrl/facemgr/src/interface.h
new file mode 100644
index 000000000..f38313182
--- /dev/null
+++ b/ctrl/facemgr/src/interface.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file interface.h
+ * \brief Interface base class
+ *
+ * Interfaces are the priviledged way to extend the functionalities of the face
+ * manager. They both provide input and/or output functionality to allow for
+ * several components to interoperate, respectively by raising/receiving events
+ * about changes in the underlying network.
+ *
+ * All communication happens through base operations (create, delete, etc.) over
+ * a generic face abstraction.
+ */
+#ifndef FACEMGR_INTERFACE_H
+#define FACEMGR_INTERFACE_H
+
+#include <stdbool.h>
+
+struct event_s;
+typedef int (*callback_t)(struct event_s * event, void * callback_data);
+
+struct interface_s;
+struct face_rules_s;
+
+/**
+ * \brief Interface operations
+ */
+typedef struct {
+    char * type;
+    bool is_singleton;
+    int (*initialize)(struct interface_s * interface, struct face_rules_s * rules, void ** pdata);
+    int (*finalize)(struct interface_s * interface);
+    int (*callback)(struct interface_s * interface);
+    int (*on_event)(struct interface_s * interface, const struct event_s * event);
+} interface_ops_t;
+
+typedef struct interface_s {
+    char * name;
+    interface_ops_t * ops;
+    callback_t callback;
+    void * callback_data;
+    void * data;
+} interface_t;
+
+/**
+ * \brief Registers a new interface type
+ * \param [in] ops - Virtual function table representing the interface
+ *     operations.
+ * \return Flag indicating the success (FACEMGR_SUCCESS=0), or failure (any
+ *     other value) of the operation.
+ */
+int interface_register(const interface_ops_t * ops);
+
+/**
+ * \brief Create a new instance of an interface of a given type.
+ * \param [in] name - Name of the newly create interface instance.
+ * \param [in] type - Name of the interface type to create.
+ * \return A a pointer to the newly created instance of the requested type, or
+ *     NULL in case of failure.
+ */
+interface_t * interface_create(const char * name, const char * type);
+
+/**
+ * \brief Free an interface instance.
+ * \param [in] interface - Pointer to the instance to free.
+ */
+void interface_free(interface_t * interface);
+
+/**
+ * This function is equivalent to interface_set_callback, which should be
+ * preferred. The difference is the lack of explicit type casts which should
+ * simplify the calling syntax.
+ */
+
+void _interface_set_callback(interface_t * interface, callback_t callback, void * callback_data);
+#define interface_set_callback(interface, callback, callback_data) \
+    _interface_set_callback(interface, (callback_t)callback, (void*)callback_data)
+
+int interface_initialize(interface_t * interface, struct face_rules_s * rules);
+int interface_finalize(interface_t * interface);
+
+int interface_on_event(interface_t * interface, const struct event_s * event);
+
+#endif /* FACEMGR_INTERFACE_H */
diff --git a/ctrl/facemgr/src/interface_map.c b/ctrl/facemgr/src/interface_map.c
new file mode 100644
index 000000000..9f7c20cab
--- /dev/null
+++ b/ctrl/facemgr/src/interface_map.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2017-2019 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 "interface_map.h"
+
+#include <string.h>
+#include "interface.h"
+
+TYPEDEF_MAP(interface_map, const char *, interface_t *, strcmp, string_snprintf, generic_snprintf);
diff --git a/ctrl/facemgr/src/interface_map.h b/ctrl/facemgr/src/interface_map.h
new file mode 100644
index 000000000..5930b3001
--- /dev/null
+++ b/ctrl/facemgr/src/interface_map.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INTERFACE_MAP_H
+#define INTERFACE_MAP_H
+
+#include "interface.h"
+#include "util/map.h"
+
+TYPEDEF_MAP_H(interface_map, const char *, interface_t *);
+
+#endif /* INTERFACE_MAP_H */
diff --git a/ctrl/facemgr/src/interface_ops_map.c b/ctrl/facemgr/src/interface_ops_map.c
new file mode 100644
index 000000000..373f5d22f
--- /dev/null
+++ b/ctrl/facemgr/src/interface_ops_map.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2017-2019 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 "interface_ops_map.h"
+
+#include <string.h>
+#include "util/map.h"
+
+TYPEDEF_MAP(interface_ops_map, const char *, interface_ops_t *, strcmp, string_snprintf, generic_snprintf);
diff --git a/ctrl/facemgr/src/interface_ops_map.h b/ctrl/facemgr/src/interface_ops_map.h
new file mode 100644
index 000000000..2d590390a
--- /dev/null
+++ b/ctrl/facemgr/src/interface_ops_map.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INTERFACE_OPS_MAP_H
+#define INTERFACE_OPS_MAP_H
+
+#include "interface.h"
+#include "util/map.h"
+
+TYPEDEF_MAP_H(interface_ops_map, const char *, interface_ops_t *);
+
+#endif /* INTERFACE_OPS_MAP_H */
diff --git a/ctrl/facemgr/src/interfaces/CMakeLists.txt b/ctrl/facemgr/src/interfaces/CMakeLists.txt
new file mode 100644
index 000000000..e5a26177a
--- /dev/null
+++ b/ctrl/facemgr/src/interfaces/CMakeLists.txt
@@ -0,0 +1,36 @@
+# Copyright (c) 2017-2019 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.
+
+list(APPEND HEADER_FILES)
+list(APPEND SOURCE_FILES)
+list(APPEND INCLUDE_DIRS)
+list(APPEND LIBRARIES)
+
+add_subdirectory(hicn_light)
+
+if(APPLE)
+add_subdirectory(network_framework)
+endif()
+
+if(LINUX)
+add_subdirectory(netlink)
+endif()
+
+if(false)
+add_subdirectory(dummy)
+endif()
+
+set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
+set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
+set(INCLUDE_DIRS ${INCLUDE_DIRS} PARENT_SCOPE)
+set(LIBRARIES    ${LIBRARIES}    PARENT_SCOPE)
diff --git a/ctrl/facemgr/src/interfaces/dummy/CMakeLists.txt b/ctrl/facemgr/src/interfaces/dummy/CMakeLists.txt
new file mode 100644
index 000000000..1af3b4b2a
--- /dev/null
+++ b/ctrl/facemgr/src/interfaces/dummy/CMakeLists.txt
@@ -0,0 +1,30 @@
+# Copyright (c) 2017-2019 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.
+
+list(APPEND HEADER_FILES
+)
+
+list(APPEND SOURCE_FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/dummy.c
+)
+
+list(APPEND INCLUDE_DIRS
+)
+
+list(APPEND LIBRARIES
+)
+
+set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
+set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
+set(INCLUDE_DIRS ${INCLUDE_DIRS} PARENT_SCOPE)
+set(LIBRARIES    ${LIBRARIES}    PARENT_SCOPE)
diff --git a/ctrl/facemgr/src/interfaces/dummy/dummy.c b/ctrl/facemgr/src/interfaces/dummy/dummy.c
new file mode 100644
index 000000000..b0c558388
--- /dev/null
+++ b/ctrl/facemgr/src/interfaces/dummy/dummy.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file dummy.c
+ * \brief Implementation of Dummy interface
+ */
+
+#include <stdlib.h>
+
+#include "../../interface.h"
+#include "../../common.h"
+#include "../../event.h"
+#include "../../face.h"
+#include "../../facemgr.h"
+
+#define DEFAULT_PORT 9695
+
+int dummy_initialize(interface_t * interface, face_rules_t * rules, void **pdata) {
+    ip_address_t local = IPV4_LOOPBACK;
+    ip_address_t remote = IPV4_LOOPBACK;
+    face_t * face = face_create_udp(&local, DEFAULT_PORT, &remote, DEFAULT_PORT, AF_INET);
+    event_raise(EVENT_TYPE_CREATE, face, interface);
+    return FACEMGR_SUCCESS;
+}
+
+int dummy_finalize(interface_t * interface) {
+    return FACEMGR_SUCCESS;
+}
+
+interface_ops_t dummy_ops = {
+    .type = "dummy",
+    .is_singleton = true,
+    .initialize = dummy_initialize,
+    .finalize = dummy_finalize,
+    .on_event = NULL,
+};
diff --git a/ctrl/facemgr/src/interfaces/hicn_light/CMakeLists.txt b/ctrl/facemgr/src/interfaces/hicn_light/CMakeLists.txt
new file mode 100644
index 000000000..ef839a69c
--- /dev/null
+++ b/ctrl/facemgr/src/interfaces/hicn_light/CMakeLists.txt
@@ -0,0 +1,33 @@
+# Copyright (c) 2017-2019 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.
+
+list(APPEND HEADER_FILES
+)
+
+list(APPEND SOURCE_FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_light.c
+)
+
+list(APPEND LIBRARIES
+    ${HICNCTRL_LIBRARIES}
+)
+
+
+list(APPEND INCLUDE_DIRS
+    ${HICNCTRL_INCLUDE_DIR}
+)
+
+set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
+set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
+set(INCLUDE_DIRS ${INCLUDE_DIRS} PARENT_SCOPE)
+set(LIBRARIES    ${LIBRARIES}    PARENT_SCOPE)
diff --git a/ctrl/facemgr/src/interfaces/hicn_light/hicn_light.c b/ctrl/facemgr/src/interfaces/hicn_light/hicn_light.c
new file mode 100644
index 000000000..85694573d
--- /dev/null
+++ b/ctrl/facemgr/src/interfaces/hicn_light/hicn_light.c
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file interfaces/hicn_light/hicn_light.c
+ * \brief hICN light interface
+ */
+#include <stdbool.h>
+#include <stdlib.h> // arc4random [random, rand]
+#include <stdio.h> // snprintf
+#include <time.h> // time
+
+#include <hicn/ctrl.h>
+
+#include "../../facemgr.h"
+#include "../../interface.h"
+#include "../../util/ip_address.h"
+#include "../../util/log.h"
+#include "../../util/map.h"
+#include "../../event.h"
+
+#define DEFAULT_ROUTE_COST 0
+
+typedef struct {
+    hc_sock_t * s;
+    bool busy;
+} hl_data_t;
+
+int hl_initialize(interface_t * interface, face_rules_t * rules, void ** pdata)
+{
+    hl_data_t * data = malloc(sizeof(hl_data_t));
+    if (!data) {
+        ERROR("[hicn_light] Out of memory!");
+        goto ERR_MALLOC;
+    }
+
+    data->s = hc_sock_create();
+    if (data->s <= 0) {
+        ERROR("[hicn_light] Could not create control socket");
+        goto ERR_SOCK;
+    }
+
+    if (hc_sock_connect(data->s) < 0) {
+        ERROR("[hicn_light] Could not connect control socket");
+        goto ERR_CONNECT;
+    }
+
+    data->busy = false;
+
+    *pdata = data;
+
+    return FACEMGR_SUCCESS;
+
+ERR_CONNECT:
+    hc_sock_free(data->s);
+ERR_SOCK:
+    free(data);
+ERR_MALLOC:
+    return FACEMGR_FAILURE;
+}
+
+int hl_finalize(interface_t * interface)
+{
+    //hc_data_t * data = interface->data;
+    //hc_sock_close(data->s);
+    return FACEMGR_SUCCESS;
+}
+
+int hl_on_event(interface_t * interface, const event_t * event)
+{
+    hc_face_t face;
+    hc_route_t route;
+    int rc;
+    hl_data_t * data = (hl_data_t *)interface->data;
+
+    /* XXX We need  a queue or a socket pool to process concurrent events */
+    if (data->busy) {
+        ERROR("[hicn_light] Busy !");
+        return FACEMGR_FAILURE;
+    }
+
+    switch(event->type) {
+        case EVENT_TYPE_CREATE:
+
+            /* Create face */
+            face.face = *event->face;
+            rc = hc_face_create(data->s, &face);
+            if (rc < 0) {
+                ERROR("Failed to create face\n");
+                goto ERR;
+            }
+            DEBUG("Created face id=%d\n", face.id);
+
+#if 0
+            /* Add default route v4 */
+            route = (hc_route_t) {
+                .face_id = face.id,
+                .family = AF_INET,
+                .remote_addr = IPV4_ANY,
+                .len = 0,
+                .cost = DEFAULT_ROUTE_COST,
+
+            };
+            if (hc_route_create(data->s, &route) < 0) {
+                ERROR("Failed to create default hICN/IPv4 route");
+                goto ERR;
+            }
+            INFO("Successfully created default hICN/IPv4 route.");
+#endif
+
+#if 0
+            route = (hc_route_t) {
+                .face_id = face.id,
+                .family = AF_INET6,
+                .remote_addr = IPV6_ANY,
+                .len = 0,
+                .cost = DEFAULT_ROUTE_COST,
+            };
+            if (hc_route_create(data->s, &route) < 0) {
+                ERROR("Failed to create default hICN/IPv6 route");
+                goto ERR;
+            }
+#endif
+
+#if 1
+            /* We add routes based on face tags */
+
+            if (policy_tags_has(event->face->tags, POLICY_TAG_TRUSTED)) {
+                route = (hc_route_t) {
+                    .face_id = face.id,
+                    .family = AF_INET6,
+                    .len = 16,
+                    .cost = DEFAULT_ROUTE_COST,
+                };
+                if (ip_address_pton("b001::", &route.remote_addr) < 0) {
+                    ERROR("Failed to convert prefix");
+                    goto ERR;
+                }
+                if (hc_route_create(data->s, &route) < 0) {
+                    ERROR("Failed to create hICN/IPv6 route");
+                    goto ERR;
+                }
+
+                route = (hc_route_t) {
+                    .face_id = face.id,
+                    .family = AF_INET6,
+                    .len = 16,
+                    .cost = DEFAULT_ROUTE_COST,
+                };
+                if (ip_address_pton("d001::", &route.remote_addr) < 0) {
+                    ERROR("Failed to convert prefix");
+                    goto ERR;
+                }
+                if (hc_route_create(data->s, &route) < 0) {
+                    ERROR("Failed to create hICN/IPv6 route");
+                    goto ERR;
+                }
+
+            } else {
+
+                route = (hc_route_t) {
+                    .face_id = face.id,
+                    .family = AF_INET6,
+                    .len = 16,
+                    .cost = DEFAULT_ROUTE_COST,
+                };
+                if (ip_address_pton("c001::", &route.remote_addr) < 0) {
+                    ERROR("Failed to convert prefix");
+                    goto ERR;
+                }
+                if (hc_route_create(data->s, &route) < 0) {
+                    ERROR("Failed to create hICN/IPv6 route");
+                    goto ERR;
+                }
+            }
+#endif
+
+            break;
+
+        case EVENT_TYPE_DELETE:
+            /* Removing a face should also remove associated routes */
+            /* Create face */
+            face.face = *event->face;
+            rc = hc_face_delete(data->s, &face);
+            if (rc < 0) {
+                ERROR("Failed to delete face\n");
+                goto ERR;
+            }
+            INFO("Deleted face id=%d\n", face.id);
+            break;
+
+        default:
+            ERROR("Unknown event %s\n", event_type_str[event->type]);
+            /* Unsupported events */
+            goto ERR;
+    }
+
+    return FACEMGR_SUCCESS;
+
+ERR:
+    return FACEMGR_FAILURE;
+}
+
+const interface_ops_t hicn_light_ops = {
+    .type = "hicn_light",
+    .is_singleton = false,
+    .initialize = hl_initialize,
+    .finalize = hl_finalize,
+    .on_event = hl_on_event,
+};
diff --git a/ctrl/facemgr/src/interfaces/netlink/CMakeLists.txt b/ctrl/facemgr/src/interfaces/netlink/CMakeLists.txt
new file mode 100644
index 000000000..7f44d87fe
--- /dev/null
+++ b/ctrl/facemgr/src/interfaces/netlink/CMakeLists.txt
@@ -0,0 +1,30 @@
+# Copyright (c) 2017-2019 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.
+
+list(APPEND HEADER_FILES
+)
+
+list(APPEND SOURCE_FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/netlink.c
+)
+
+list(APPEND LIBRARIES
+)
+
+list(APPEND INCLUDE_DIRS
+)
+
+set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
+set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
+set(INCLUDE_DIRS ${INCLUDE_DIRS} PARENT_SCOPE)
+set(LIBRARIES    ${LIBRARIES}    PARENT_SCOPE)
diff --git a/ctrl/facemgr/src/interfaces/netlink/netlink.c b/ctrl/facemgr/src/interfaces/netlink/netlink.c
new file mode 100644
index 000000000..5bf0baf9f
--- /dev/null
+++ b/ctrl/facemgr/src/interfaces/netlink/netlink.c
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file interfaces/netlink/netlink.c
+ * \brief Netlink interface
+ */
+
+#include <linux/rtnetlink.h>
+#include <sys/types.h> // getpid
+#include <unistd.h> // getpid
+
+#include "../../event.h"
+#include "../../facemgr.h"
+#include "../../interface.h"
+
+/* Internal data storage */
+typedef struct {
+    int fd;
+} nl_data_t;
+
+// little helper to parsing message using netlink macroses
+void parseRtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len)
+{
+    memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
+
+    while (RTA_OK(rta, len)) {  // while not end of the message
+        if (rta->rta_type <= max) {
+            tb[rta->rta_type] = rta; // read attr
+        }
+        rta = RTA_NEXT(rta,len);    // get next attr
+    }
+}
+
+
+int nl_initialize(interface_t * interface, face_rules_t * rules, void ** pdata)
+{
+    nl_data_t * data = malloc(sizeof(nl_data_t));
+    if (!data)
+        goto ERR_MALLOC;
+
+    data->fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+    if (data->fd < 0) {
+        printf("Failed to create netlink socket: %s\n", (char*)strerror(errno));
+        goto ERR_SOCKET;
+    }
+
+    struct sockaddr_nl  local;  // local addr struct
+    memset(&local, 0, sizeof(local));
+    local.nl_family = AF_NETLINK;       // set protocol family
+    local.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV4_ROUTE;   // set groups we interested in
+    local.nl_pid = getpid();    // set out id using current process id
+
+
+    if (bind(data->fd, (struct sockaddr*)&local, sizeof(local)) < 0) {     // bind socket
+        printf("Failed to bind netlink socket: %s\n", (char*)strerror(errno));
+        goto ERR_BIND;
+    }
+
+    /* Issue a first query to receive static state */
+
+
+    *pdata = data;
+    return data->fd; // FACEMGR_SUCCESS;
+
+ERR_BIND:
+    close(data->fd);
+ERR_SOCKET:
+    free(data);
+ERR_MALLOC:
+    *pdata = NULL;
+    return FACEMGR_FAILURE;
+}
+
+int nl_callback(interface_t * interface)
+{
+    nl_data_t * data = (nl_data_t*)interface->data;
+
+    struct sockaddr_nl  local;  // local addr struct
+    memset(&local, 0, sizeof(local));
+
+    char buf[8192];             // message buffer
+    struct iovec iov;           // message structure
+    iov.iov_base = buf;         // set message buffer as io
+    iov.iov_len = sizeof(buf);  // set size
+
+    // initialize protocol message header
+    struct msghdr msg;
+    {
+        msg.msg_name = &local;                  // local address
+        msg.msg_namelen = sizeof(local);        // address size
+        msg.msg_iov = &iov;                     // io vector
+        msg.msg_iovlen = 1;                     // io size
+    }
+
+    ssize_t status = recvmsg(data->fd, &msg, 0);
+
+    //  check status
+    if (status < 0) {
+/*
+        if (errno == EINTR || errno == EAGAIN)
+            continue;
+*/
+
+        printf("Failed to read netlink: %s", (char*)strerror(errno));
+        return FACEMGR_FAILURE;
+    }
+
+    if (msg.msg_namelen != sizeof(local)) { // check message length, just in case
+        printf("Invalid length of the sender address struct\n");
+        return FACEMGR_FAILURE;
+    }
+
+    // message parser
+    struct nlmsghdr *h;
+
+    for (h = (struct nlmsghdr*)buf; status >= (ssize_t)sizeof(*h); ) {   // read all messagess headers
+        int len = h->nlmsg_len;
+        int l = len - sizeof(*h);
+        char *ifName = NULL;
+
+        if ((l < 0) || (len > status)) {
+            printf("Invalid message length: %i\n", len);
+            continue;
+        }
+
+        // now we can check message type
+        if ((h->nlmsg_type == RTM_NEWROUTE) || (h->nlmsg_type == RTM_DELROUTE)) { // some changes in routing table
+            printf("Routing table was changed\n");
+        } else {    // in other case we need to go deeper
+            char *ifUpp;
+            char *ifRunn;
+            struct ifinfomsg *ifi;  // structure for network interface info
+            struct rtattr *tb[IFLA_MAX + 1];
+
+            ifi = (struct ifinfomsg*) NLMSG_DATA(h);    // get information about changed network interface
+
+            parseRtattr(tb, IFLA_MAX, IFLA_RTA(ifi), h->nlmsg_len);  // get attributes
+
+            if (tb[IFLA_IFNAME]) {  // validation
+                ifName = (char*)RTA_DATA(tb[IFLA_IFNAME]); // get network interface name
+            }
+
+            if (ifi->ifi_flags & IFF_UP) { // get UP flag of the network interface
+                ifUpp = (char*)"UP";
+            } else {
+                ifUpp = (char*)"DOWN";
+            }
+
+            if (ifi->ifi_flags & IFF_RUNNING) { // get RUNNING flag of the network interface
+                ifRunn = (char*)"RUNNING";
+            } else {
+                ifRunn = (char*)"NOT RUNNING";
+            }
+
+            char ifAddress[256] = {0};    // network addr
+            struct ifaddrmsg *ifa; // structure for network interface data
+            struct rtattr *tba[IFA_MAX+1];
+
+            ifa = (struct ifaddrmsg*)NLMSG_DATA(h); // get data from the network interface
+
+            parseRtattr(tba, IFA_MAX, IFA_RTA(ifa), h->nlmsg_len);
+
+            if (tba[IFA_LOCAL]) {
+                inet_ntop(AF_INET, RTA_DATA(tba[IFA_LOCAL]), ifAddress, sizeof(ifAddress)); // get IP addr
+            }
+
+            face_t * face;
+
+            if (tba[IFA_LOCAL]) {
+                ip_address_t local_addr = IP_ADDRESS_EMPTY;
+                switch(ifa->ifa_family) {
+                    case AF_INET:
+                        local_addr.v4.as_inaddr = *(struct in_addr*)RTA_DATA(tba[IFA_LOCAL]);
+                        break;
+                    case AF_INET6:
+                        local_addr.v6.as_in6addr = *(struct in6_addr*)RTA_DATA(tba[IFA_LOCAL]);
+                        break;
+                    default:
+                        continue;
+                }
+                face = face_create_udp(&local_addr, 0, &IP_ADDRESS_EMPTY, 0, ifa->ifa_family);
+            } else {
+                face = NULL;
+            }
+
+            switch (h->nlmsg_type) {
+                case RTM_DELADDR:
+                    // DOES NOT SEEM TO BE TRIGGERED
+                    printf("Interface %s: address was removed\n", ifName);
+                    if (face)
+                        event_raise(EVENT_TYPE_DELETE, face, interface);
+                    break;
+
+                case RTM_DELLINK:
+                    printf("Network interface %s was removed\n", ifName);
+                    break;
+
+                case RTM_NEWLINK:
+                    printf("New network interface %s, state: %s %s\n", ifName, ifUpp, ifRunn);
+                    // UP RUNNING
+                    // UP NOT RUNNING
+                    // DOWN NOT RUNNING
+                    if (!(ifi->ifi_flags & IFF_UP) || (!(ifi->ifi_flags & IFF_RUNNING))) {
+                        if(face)
+                            event_raise(EVENT_TYPE_DELETE, face, interface);
+                    }
+                    break;
+
+                case RTM_NEWADDR:
+                    printf("Interface %s: new address was assigned: %s\n", ifName, ifAddress);
+                    printf("NEW FACE\n");
+                    if (face)
+                        event_raise(EVENT_TYPE_CREATE, face, interface);
+                    break;
+            }
+        }
+
+        status -= NLMSG_ALIGN(len); // align offsets by the message length, this is important
+
+        h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));    // get next message
+    }
+
+    return FACEMGR_SUCCESS;
+}
+
+int nl_finalize(interface_t * interface)
+{
+    nl_data_t * data = (nl_data_t*)interface->data;
+    close(data->fd);
+    return FACEMGR_SUCCESS;
+
+}
+
+const interface_ops_t netlink_ops = {
+    .type = "netlink",
+    .is_singleton = true,
+    .initialize = nl_initialize,
+    .callback = nl_callback,
+    .finalize = nl_finalize,
+    .on_event = NULL,
+};
diff --git a/ctrl/facemgr/src/interfaces/network_framework/CMakeLists.txt b/ctrl/facemgr/src/interfaces/network_framework/CMakeLists.txt
new file mode 100644
index 000000000..ca6659342
--- /dev/null
+++ b/ctrl/facemgr/src/interfaces/network_framework/CMakeLists.txt
@@ -0,0 +1,36 @@
+# Copyright (c) 2017-2019 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.
+
+find_library(NETWORK_LIBRARY Network)
+if (NOT NETWORK_LIBRARY)
+    message(FATAL_ERROR "NetworkFramework not found")
+endif()
+
+list(APPEND HEADER_FILES
+)
+
+list(APPEND SOURCE_FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/network_framework.c
+)
+
+list(APPEND INCLUDE_DIRS
+)
+
+list(APPEND LIBRARIES
+    ${NETWORK_LIBRARY}
+)
+
+set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
+set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
+set(INCLUDE_DIRS ${INCLUDE_DIRS} PARENT_SCOPE)
+set(LIBRARIES    ${LIBRARIES}    PARENT_SCOPE)
diff --git a/ctrl/facemgr/src/interfaces/network_framework/network_framework.c b/ctrl/facemgr/src/interfaces/network_framework/network_framework.c
new file mode 100644
index 000000000..8a33129b4
--- /dev/null
+++ b/ctrl/facemgr/src/interfaces/network_framework/network_framework.c
@@ -0,0 +1,581 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file network_framework.c
+ * \brief Implementation of Network framework interface
+ */
+
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+#include <Network/Network.h>
+#include <err.h>
+
+#include "../../common.h"
+#include "../../event.h"
+#include "../../face.h"
+#include "../../facemgr.h"
+#include "../../interface.h"
+#include "../../util/map.h"
+#include "../../util/token.h"
+#include "../../util/log.h"
+
+/*
+ * Bonjour service discovery for hICN forwarder
+ *
+ * Possible values for BONJOUR_PROTOCOL:
+ *      udp (default) : avoid potential handshake during connection setup.
+ *      tcp
+ *
+ * Service advertisement / discovery on MacOSX
+ *
+ *      dns-sd -R hicn _hicn._tcp local 9695
+ *      dns-sd -R hicn _hicn._udp local 9695
+ *
+ *      dns-sd -B _hicn._tcp local
+ *      dns-sd -B _hicn._udp local
+ *
+ * Service discovery on Linux (various useful commandline arguments):
+ *
+ *      avahi-browse -pt _hicn._udp
+ *      avahi-browse -rp _hicn._tcp
+ */
+
+#define BONJOUR_PROTOCOL udp
+#define BONJOUR_SERVICE_DOMAIN "local"
+#define BONJOUR_SERVICE_NAME "hicn"
+
+/* Generated variables */
+#define BONJOUR_SERVICE_TYPE "_hicn._" STRINGIZE(BONJOUR_PROTOCOL)
+#define BONJOUR_PROTOCOL_NAME STRINGIZE(BONJOUR_PROTOCOL)
+#define nw_parameters_create_fn PPCAT(nw_parameters_create_secure_, BONJOUR_PROTOCOL)
+
+#define DEFAULT_PORT 9695
+
+typedef enum {
+    INTERFACE_TYPE_OTHER,
+    INTERFACE_TYPE_WIFI,
+    INTERFACE_TYPE_CELLULAR,
+    INTERFACE_TYPE_WIRED,
+    INTERFACE_TYPE_LOOPBACK,
+} _nw_interface_type_t;
+
+const char * interface_type_str[] = {
+    "OTHER", "WIFI", "CELLULAR", "WIRED", "LOOPBACK",
+};
+
+#if 0
+typedef enum {
+    PATH_STATUS_INVALID,
+    PATH_STATUS_SATISTIED,
+    PATH_STATUS_UNSATISFIED,
+    PATH_STATUS_SATISFIABLE,
+} _nw_path_status_t;
+#endif
+
+const char * path_status_str[] = {
+    "INVALID", "SATISFIED", "UNSATISFIED", "SATISFIABLE",
+};
+
+const char * endpoint_type_str[] = {
+    "INVALID", "ADDRESS", "HOST", "BONJOUR",
+};
+
+const char * connection_state_str[] = {
+    "INVALID", "WAITING", "PREPARING", "READY", "FAILED", "CANCELLED",
+};
+
+int
+cmp_iface(const nw_interface_t iface1, const nw_interface_t iface2)
+{
+    return INT_CMP(nw_interface_get_index(iface1), nw_interface_get_index(iface2));
+}
+
+//TYPEDEF_MAP(map_cnx, nw_interface_t, nw_connection_t, cmp_iface);
+
+typedef struct {
+    face_rules_t * rules; /**< Face creation rules */
+    nw_path_monitor_t pm; /**< Main path monitor */
+//    map_cnx_t map_cnx;    /**< Map: interface -> connection for face status */
+} nf_data_t;
+
+void
+dump_interface(nw_interface_t interface, int indent)
+{
+    uint32_t index = nw_interface_get_index(interface);
+    const char * name = nw_interface_get_name(interface);
+    nw_interface_type_t type = nw_interface_get_type(interface);
+
+    printfi(indent+1, "%d: %s [%s]\n", index, name, interface_type_str[type]);
+}
+
+void
+dump_endpoint(nw_endpoint_t endpoint, int indent)
+{
+    if (!endpoint) {
+        printfi(indent, "N/A\n");
+        return;
+    }
+
+    nw_endpoint_type_t endpoint_type = nw_endpoint_get_type(endpoint);
+    const char * hostname = nw_endpoint_get_hostname(endpoint);
+    short port = nw_endpoint_get_port(endpoint);
+    const struct sockaddr * address = nw_endpoint_get_address(endpoint);
+
+    printfi(indent, "Type: %s\n", endpoint_type_str[endpoint_type]);
+    printfi(indent, "Hostname: %s\n", hostname);
+    printfi(indent, "Port: %d\n", port);
+
+    if (address) {
+        char *s = NULL;
+        switch(address->sa_family) {
+            case AF_INET: {
+                              struct sockaddr_in *addr_in = (struct sockaddr_in *)address;
+                              s = malloc(INET_ADDRSTRLEN);
+                              inet_ntop(AF_INET, &(addr_in->sin_addr), s, INET_ADDRSTRLEN);
+                              break;
+                          }
+            case AF_INET6: {
+                               struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)address;
+                               s = malloc(INET6_ADDRSTRLEN);
+                               inet_ntop(AF_INET6, &(addr_in6->sin6_addr), s, INET6_ADDRSTRLEN);
+                               break;
+                           }
+            default:
+                           break;
+        }
+        printfi(indent, "IP address: %s\n", s);
+        free(s);
+    }
+}
+
+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_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);
+
+    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);
+}
+
+face_t *
+face_create_from_connection(nw_connection_t connection, face_rules_t * rules)
+{
+    face_t * face;
+    struct sockaddr_in * sin;
+    struct sockaddr_in6 * sin6;
+
+    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_addr = nw_endpoint_get_address(local);
+    const struct sockaddr * remote_addr = nw_endpoint_get_address(remote);
+
+    assert (local_addr->sa_family == remote_addr->sa_family);
+    switch(local_addr->sa_family) {
+        case AF_INET:
+            sin = (struct sockaddr_in *)local_addr;
+            sin->sin_port = htons(DEFAULT_PORT);
+            sin = (struct sockaddr_in *)remote_addr;
+            sin->sin_port = htons(DEFAULT_PORT);
+            break;
+        case AF_INET6:
+            sin6 = (struct sockaddr_in6 *)local_addr;
+            sin6->sin6_port = htons(DEFAULT_PORT);
+            sin6 = (struct sockaddr_in6 *)remote_addr;
+            sin6->sin6_port = htons(DEFAULT_PORT);
+            break;
+        default:
+            ERROR("Unsupported address family: %d\n", local_addr->sa_family);
+            return NULL;
+    }
+
+    face = face_create_udp_sa(local_addr, remote_addr);
+
+    /* 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;
+    });
+    nw_interface_type_t type = nw_interface_get_type(interface);
+    const char * name = nw_interface_get_name(interface);
+
+    policy_tags_t tags = POLICY_TAGS_EMPTY;
+
+    if (rules) {
+        if (!FACEMGR_IS_ERROR(face_rules_get(rules, name, &tags)))
+            goto SET_TAGS;
+
+        char tags[MAXSZ_POLICY_TAGS];
+        policy_tags_snprintf(tags, MAXSZ_POLICY_TAGS, face->tags);
+    }
+
+    switch(type) {
+        case INTERFACE_TYPE_OTHER:
+            policy_tags_add(&tags, POLICY_TAG_WIFI);
+            policy_tags_add(&tags, POLICY_TAG_TRUSTED);
+            break;
+        case INTERFACE_TYPE_WIFI:
+            // XXX disambuiguate on interface name for now.
+            policy_tags_add(&tags, POLICY_TAG_WIFI);
+            policy_tags_add(&tags, POLICY_TAG_TRUSTED);
+            break;
+        case INTERFACE_TYPE_CELLULAR:
+            policy_tags_add(&tags, POLICY_TAG_CELLULAR);
+            break;
+        case INTERFACE_TYPE_WIRED:
+            /* Both VPN and USB WiFi are not well detected on MacOS. For USB
+             * WiFi, we currently have no solution. For VPN, until we have
+             * proper support of AnyC APIs, we need to have heuristics to
+             * determine VPN interfaces. */
+            policy_tags_add(&tags, POLICY_TAG_WIRED);
+            policy_tags_add(&tags, POLICY_TAG_TRUSTED);
+            break;
+        case INTERFACE_TYPE_LOOPBACK:
+            tags = POLICY_TAGS_EMPTY;
+            break;
+        default:
+            break;
+
+    }
+
+SET_TAGS:
+    face_set_tags(face, tags);
+
+    nw_release(local);
+    nw_release(remote);
+    nw_release(path);
+
+    return face;
+}
+
+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 0
+    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 */
+
+    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;
+
+        case nw_connection_state_preparing:
+            break;
+
+        case nw_connection_state_ready:
+            {
+#if 0
+            WITH_DEBUG({
+                dump_connection(cnx, 1);
+            });
+#endif
+            nf_data_t * data = (nf_data_t*)interface->data;
+            face_t * face = face_create_from_connection(cnx, data->rules);
+            event_raise(EVENT_TYPE_CREATE, face, interface);
+            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;
+
+    }
+
+    nw_release(remote);
+
+}
+
+void
+on_connection_path_event(interface_t * interface, nw_interface_t iface,
+        nw_connection_t cnx, nw_path_t path)
+{
+#if 0
+    DEBUG("Connection [path changed]:\n");
+    WITH_DEBUG({
+        //dump_connection(cnx, 1);
+    });
+#endif
+    /* redundant *//*
+    DEBUG(1, "Path:\n");
+    dump_path(path, 2);
+    */
+}
+
+/**
+ * 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 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.
+     */
+
+    nw_endpoint_t endpoint;
+
+    endpoint = nw_endpoint_create_bonjour_service(
+            BONJOUR_SERVICE_NAME,
+            BONJOUR_SERVICE_TYPE,
+            BONJOUR_SERVICE_DOMAIN);
+
+    if (!endpoint)
+        goto ERR;
+
+    /* 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;
+
+    nw_parameters_require_interface(parameters, iface);
+    nw_parameters_set_reuse_local_address(parameters, true);
+
+    nw_connection_t connection = nw_connection_create(endpoint, parameters);
+    if (!connection)
+        goto ERR;
+
+    nw_release(endpoint);
+    nw_release(parameters);
+
+    /* Remember not to recreate connection */
+    // XXX TODO
+
+    /* 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_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) {
+#if 0
+        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) {
+#if 0
+        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
+         */
+        nf_data_t * data = (nf_data_t*)interface->data;
+        face_t * face = face_create_from_connection(connection, data->rules);
+        //event_raise(value ? EVENT_TYPE_SET_UP : EVENT_TYPE_SET_DOWN, face, interface);
+        if(value) {
+            event_raise(EVENT_TYPE_CREATE, face, interface);
+        } else {
+            event_raise(EVENT_TYPE_DELETE, face, interface);
+        }
+
+    });
+
+    nw_connection_start(connection);
+
+    nw_connection_set_queue(connection, dispatch_get_main_queue());
+    nw_retain(connection); // Hold a reference until cancelled
+
+#if 0
+    DEBUG("Created Bonjour cnx on interface:\n");
+    WITH_DEBUG({
+        dump_interface(iface, 1);
+    });
+#endif
+
+ERR:
+    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
+     */
+#if 0
+    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;
+    });
+
+}
+
+int nf_initialize(interface_t * interface, face_rules_t * rules, void ** pdata)
+{
+    nf_data_t * data = malloc(sizeof(nf_data_t));
+    if (!data)
+        goto ERR_MALLOC;
+
+    data->rules = rules;
+
+    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);
+            });
+
+    // XXX NEEDED ?
+    nw_retain(data->pm);
+
+    DEBUG("Starting network path monitor");
+    nw_path_monitor_start(data->pm);
+
+    *pdata = data;
+    return FACEMGR_SUCCESS;
+
+ERR_PM:
+    free(data);
+ERR_MALLOC:
+    *pdata = NULL;
+    return FACEMGR_FAILURE;
+}
+
+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 FACEMGR_SUCCESS;
+}
+
+const interface_ops_t network_framework_ops = {
+    .type = "network_framework",
+    .is_singleton = true,
+    .initialize = nf_initialize,
+    .finalize = nf_finalize,
+    .on_event = NULL,
+};
diff --git a/ctrl/facemgr/src/main.c b/ctrl/facemgr/src/main.c
new file mode 100644
index 000000000..6a80d806b
--- /dev/null
+++ b/ctrl/facemgr/src/main.c
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file main.c
+ * \brief Face manager daemon entry point
+ */
+
+#include <getopt.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h> // faccess
+
+#include <libconfig.h>
+
+#include "util/log.h"
+#include "util/policy.h"
+
+#ifdef __APPLE__
+#include <Dispatch/Dispatch.h>
+#else
+// Note: we might want to use libevent on Apple too
+#include <event2/event.h>
+#endif
+
+#include "facemgr.h"
+
+#define FACEMGR_TIMEOUT 3
+
+
+static struct option long_options[] =
+{
+    {"config",  required_argument, 0, 'c'},
+    {0, 0, 0, 0}
+};
+
+typedef struct {
+    char * cfgfile;
+} facemgr_options_t;
+
+static const char * DEFAULT_CFGFILES[] = {
+    "/etc/facemgr.conf",
+    "~/facemgr.conf",
+};
+
+#define ARRAYSIZE(x) (sizeof(x)/sizeof(*x))
+
+void usage(const char * progname)
+{
+    printf("%s: Face manager daemon\n", progname);
+    printf("\n");
+    printf("Usage: %s [OPTIONS]\n", progname);
+    printf("\n");
+    printf("OPTIONS:\n");
+    printf("  -c  --config [FILE|none]    Sets the configuration file (unless none, default: /etc/facemgr.conf, ~/facemgr.conf)\n");
+    printf("\n");
+}
+
+int probe_cfgfile(char * f)
+{
+    for (unsigned i = 0; i < ARRAYSIZE(DEFAULT_CFGFILES); i++) {
+        if (access(DEFAULT_CFGFILES[i], F_OK ) != -1) {
+            if (!realpath(DEFAULT_CFGFILES[i], f))
+                continue;
+            return 0;
+        }
+    }
+    return -1;
+}
+
+int parse_cmdline(int argc, char ** argv, facemgr_options_t * opts)
+{
+    int c;
+    while ((c = getopt_long(argc, argv, "c:", long_options, NULL)) != -1) {
+        switch(c) {
+            case 'c':
+                opts->cfgfile = strdup(optarg);
+                break;
+            case ':':
+            case '?':
+            default:
+                usage(argv[0]);
+                exit(EXIT_FAILURE);
+        }
+
+    }
+    return 0;
+}
+
+int parse_config_file(const char * cfgpath, facemgr_t * facemgr)
+{
+    /* Reading configuration file */
+    config_t cfg;
+    config_setting_t *setting;
+
+    config_init(&cfg);
+
+    /* Read the file. If there is an error, report it and exit. */
+    if(!config_read_file(&cfg, cfgpath))
+        goto ERR_FILE;
+
+    setting = config_lookup(&cfg, "log");
+    if (setting) {
+        const char *log_level_str;
+        if (config_setting_lookup_string(setting, "log_level", &log_level_str)) {
+            if (strcmp(log_level_str, "FATAL") == 0) {
+                log_conf.log_level = LOG_FATAL;
+            } else
+            if (strcmp(log_level_str, "ERROR") == 0) {
+                log_conf.log_level = LOG_ERROR;
+            } else
+            if (strcmp(log_level_str, "WARN") == 0) {
+                log_conf.log_level = LOG_WARN;
+            } else
+            if (strcmp(log_level_str, "INFO") == 0) {
+                log_conf.log_level = LOG_INFO;
+            } else
+            if (strcmp(log_level_str, "DEBUG") == 0) {
+                log_conf.log_level = LOG_DEBUG;
+            } else
+            if (strcmp(log_level_str, "TRACE") == 0) {
+                log_conf.log_level = LOG_TRACE;
+            } else {
+                printf("Ignored unknown log level\n");
+            }
+        }
+    }
+
+    setting = config_lookup(&cfg, "faces.overlay.ipv4");
+    if (setting) {
+        const char * ip_address;
+        int local_port, remote_port;
+        if (config_setting_lookup_int(setting, "local_port", &local_port)) {
+            if ((local_port < 0) || (local_port > MAX_PORT))
+                goto ERR;
+            facemgr->overlay_v4_local_port = (uint16_t)local_port;
+        }
+
+        if (config_setting_lookup_int(setting, "remote_port", &remote_port)) {
+            if ((remote_port < 0) || (remote_port > MAX_PORT))
+                goto ERR;
+            facemgr->overlay_v4_remote_port = (uint16_t)remote_port;
+        }
+
+        if (config_setting_lookup_string(setting, "remote_addr", &ip_address)) {
+            ip_address_pton(ip_address, &facemgr->overlay_v4_remote_addr);
+            printf("got v4 remote addr\n");
+        }
+    }
+
+    setting = config_lookup(&cfg, "faces.overlay.ipv6");
+    if (setting) {
+        const char * ip_address;
+        int local_port, remote_port;
+        if (config_setting_lookup_int(setting, "local_port", &local_port)) {
+            if ((local_port < 0) || (local_port > MAX_PORT))
+                goto ERR;
+            facemgr->overlay_v6_local_port = (uint16_t)local_port;
+        }
+
+        if (config_setting_lookup_int(setting, "remote_port", &remote_port)) {
+            if ((remote_port < 0) || (remote_port > MAX_PORT))
+                goto ERR;
+            facemgr->overlay_v6_remote_port = (uint16_t)remote_port;
+        }
+
+        if (config_setting_lookup_string(setting, "remote_addr", &ip_address))
+            ip_address_pton(ip_address, &facemgr->overlay_v6_remote_addr);
+    }
+
+    setting = config_lookup(&cfg, "faces.rules");
+    if (setting) {
+        int count = config_setting_length(setting);
+        for(unsigned i = 0; i < count; ++i) {
+            const char *interface_name;
+            policy_tags_t tags = POLICY_TAGS_EMPTY;
+
+            config_setting_t *rule = config_setting_get_elem(setting, i);
+
+            /* Interface name */
+            if(!(config_setting_lookup_string(rule, "name", &interface_name)))
+                continue;
+
+            /* Associated tags */
+            config_setting_t *tag_settings = config_setting_get_member(rule, "tags");
+            if (!tag_settings)
+                goto ERR;
+
+
+            for (unsigned j = 0; j < config_setting_length(tag_settings); j++) {
+                const char * tag_str = config_setting_get_string_elem(tag_settings, j);
+                policy_tag_t tag = policy_tag_from_str(tag_str);
+                if (tag == POLICY_TAG_N)
+                    goto ERR;
+                policy_tags_add(&tags, tag);
+            }
+
+            /* debug */
+            char tags_str[MAXSZ_POLICY_TAGS];
+            policy_tags_snprintf(tags_str, MAXSZ_POLICY_TAGS, tags);
+            printf("Rule #%d interface_name=%s, tags=%s\n", i, interface_name, tags_str);
+            face_rules_add(&facemgr->rules, strdup(interface_name), tags);
+        }
+    }
+
+    config_destroy(&cfg);
+    return 0;
+
+ERR_FILE:
+    printf("Could not read configuration file %s\n", cfgpath);
+    fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
+            config_error_line(&cfg), config_error_text(&cfg));
+    config_destroy(&cfg);
+    exit(EXIT_FAILURE);
+    return -1;
+ERR:
+    fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
+            config_error_line(&cfg), config_error_text(&cfg));
+    config_destroy(&cfg);
+    return -1;
+}
+
+#ifndef APPLE
+void dummy_handler(int fd, short event, void *arg) { }
+#endif /* APPLE */
+
+
+int main(int argc, char **argv)
+{
+    facemgr_t * facemgr = facemgr_create();
+    if (!facemgr)
+        goto ERR_FACEMGR;
+
+    char cfgfile[PATH_MAX];
+
+    // TODO: default < config < commandline on a per option basis
+
+    /* Commandline */
+    facemgr_options_t cmdline_opts = {0};
+    if (parse_cmdline(argc, argv, &cmdline_opts) < 0) {
+        ERROR("Error parsing commandline\n");
+        goto ERR_CMDLINE;
+    }
+
+    /* Configuration file */
+    //facemgr_options_t cfgfile_opts;
+
+    if (cmdline_opts.cfgfile) {
+        if (strcmp(cmdline_opts.cfgfile, "none") == 0)
+            goto NO_CFGFILE;
+
+        if (!realpath(cmdline_opts.cfgfile, (char*)&cfgfile))
+            goto ERR_PATH;
+
+        goto PARSE_CFGFILE;
+    }
+
+    /* No commandline path specifed, probe default locations... */
+
+    if (probe_cfgfile(cfgfile) < 0)
+        goto NO_CFGFILE;
+
+    printf("Using configuration file %s\n", cfgfile);
+
+PARSE_CFGFILE:
+
+    if (parse_config_file(cfgfile, facemgr) < 0) {
+        ERROR("Error parsing configuration file %s\n", cfgfile);
+        goto ERR_PARSE;
+    }
+
+NO_CFGFILE:
+
+#ifdef __linux__
+    facemgr->loop = event_base_new();
+    if (!facemgr->loop)
+        fatal("Could not create an event base");
+
+    /* Main loop
+     *
+     * To avoid the loop to exit when empty, we might either rely on an option
+     * introduced from versions 2.1.x:
+     *   event_base_loop(loop->base, EVLOOP_NO_EXIT_ON_EMPTY);
+     * or use this workaround:
+     *   http://archives.seul.org/libevent/users/Sep-2012/msg00056.html
+     *
+     * TODO:
+     *  - HUP should interrupt the main loop
+     */
+    {
+        struct event *ev;
+        struct timeval tv;
+        tv.tv_sec = FACEMGR_TIMEOUT;
+        tv.tv_usec = 0;
+
+        ev = event_new(facemgr->loop, fileno(stdin), EV_TIMEOUT | EV_PERSIST, dummy_handler, NULL);
+        event_add(ev, &tv);
+    }
+#endif /* __linux__ */
+
+    DEBUG("Bootstrap...\n");
+    if (facemgr_bootstrap(facemgr) < 0 )
+        goto ERR_BOOTSTRAP;
+
+#ifdef __linux__
+    event_set_log_callback(NULL);
+    event_base_dispatch(facemgr->loop);
+
+    event_base_free(facemgr->loop);
+#endif /* __linux__ */
+
+#ifdef __APPLE__
+    /* Main loop */
+    facemgr->loop = NULL;
+    dispatch_main();
+#endif /* __APPLE__ */
+
+    /* Clean up */
+    //interface_delete_all();
+
+
+    facemgr_free(facemgr);
+
+    return EXIT_SUCCESS;
+
+ERR_BOOTSTRAP:
+ERR_PARSE:
+ERR_PATH:
+ERR_CMDLINE:
+    facemgr_free(facemgr);
+ERR_FACEMGR:
+    return EXIT_FAILURE;
+
+}
+
diff --git a/ctrl/facemgr/src/netdevice.c b/ctrl/facemgr/src/netdevice.c
new file mode 100644
index 000000000..817b0e47b
--- /dev/null
+++ b/ctrl/facemgr/src/netdevice.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file netdevice.c
+ * \brief Implementation of Netdevice abstraction
+ */
+
+#include "common.h"
+#include "netdevice.h"
+
+const char * netdevice_type_str[] = {
+#define _(x) [NETDEVICE_TYPE_ ## x] = STRINGIZE(x),
+foreach_netdevice_type
+#undef _
+}
diff --git a/ctrl/facemgr/src/netdevice.h b/ctrl/facemgr/src/netdevice.h
new file mode 100644
index 000000000..b64ad0f9a
--- /dev/null
+++ b/ctrl/facemgr/src/netdevice.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file netdevice.h
+ * \brief Netdevice abstraction
+ */
+#ifndef FACEMGR_NETDEVICE_H
+#define FACEMGR_NETDEVICE_H
+
+#include <net/if.h> // IFNAMSIZ
+
+#include "common.h"
+
+#define foreach_netdevice_type  \
+    _(UNDEFINED)                \
+    _(WIRED)                    \
+    _(WIFI)                     \
+    _(CELLULAR)                 \
+    _(VPN)                      \
+    _(N)
+
+#define MAXSZ_NETDEVICE_TYPE 9
+#define MAXSZ_NETDEVICE_TYPE_ MAXSZ_NETDEVICE_TYPE
+
+typedef enum {
+#define _(x) x,
+foreach_netdevice_type
+#undef _
+} netdevice_type_t;
+
+extern const char * netdevice_type_str[];
+
+
+typedef struct {
+    u32 index;
+    char name[IFNAMSIZ];
+} netdevice_t;
+
+#endif /* FACEMGR_NETDEVICE_H */
diff --git a/ctrl/facemgr/src/util/hash.h b/ctrl/facemgr/src/util/hash.h
new file mode 100644
index 000000000..04b08eb54
--- /dev/null
+++ b/ctrl/facemgr/src/util/hash.h
@@ -0,0 +1,233 @@
+/*
+ * \file hash.h
+ * \brief Simple non-cryptographic hash implementation.
+ *
+ * Two helpers are provided :
+ *    hash(buf, len)  : hash a buffer <buf> of length <len>
+ *    hash_struct(buf) : hash a buffer corresponding to an allocated struct
+ *
+ * This file consists in excerpts from Jenkins hash (public domain).
+ * http://www.burtleburtle.net/bob/c/lookup3.c
+ */
+#ifndef UTIL_HASH_H
+#define UTIL_HASH_H
+
+#include "../common.h"
+
+#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \
+     __BYTE_ORDER == __LITTLE_ENDIAN) || \
+    (defined(i386) || defined(__i386__) || defined(__i486__) || \
+     defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL))
+# define HASH_LITTLE_ENDIAN 1
+# define HASH_BIG_ENDIAN 0
+#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \
+       __BYTE_ORDER == __BIG_ENDIAN) || \
+      (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
+# define HASH_LITTLE_ENDIAN 0
+# define HASH_BIG_ENDIAN 1
+#else
+# define HASH_LITTLE_ENDIAN 0
+# define HASH_BIG_ENDIAN 0
+#endif
+
+#define hashsize(n) ((uint32_t)1<<(n))
+#define hashmask(n) (hashsize(n)-1)
+#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
+
+#define mix(a,b,c) \
+{ \
+  a -= c;  a ^= rot(c, 4);  c += b; \
+  b -= a;  b ^= rot(a, 6);  a += c; \
+  c -= b;  c ^= rot(b, 8);  b += a; \
+  a -= c;  a ^= rot(c,16);  c += b; \
+  b -= a;  b ^= rot(a,19);  a += c; \
+  c -= b;  c ^= rot(b, 4);  b += a; \
+}
+
+#define final(a,b,c) \
+{ \
+  c ^= b; c -= rot(b,14); \
+  a ^= c; a -= rot(c,11); \
+  b ^= a; b -= rot(a,25); \
+  c ^= b; c -= rot(b,16); \
+  a ^= c; a -= rot(c,4);  \
+  b ^= a; b -= rot(a,14); \
+  c ^= b; c -= rot(b,24); \
+}
+
+static inline
+uint32_t hashlittle( const void *key, size_t length, uint32_t initval)
+{
+  uint32_t a,b,c;                                          /* internal state */
+  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
+
+  u.ptr = key;
+  if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
+    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
+
+    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      b += k[1];
+      c += k[2];
+      mix(a,b,c);
+      length -= 12;
+      k += 3;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    /*
+     * "k[2]&0xffffff" actually reads beyond the end of the string, but
+     * then masks off the part it's not allowed to read.  Because the
+     * string is aligned, the masked-off tail is in the same word as the
+     * rest of the string.  Every machine with memory protection I've seen
+     * does it on word boundaries, so is OK with this.  But VALGRIND will
+     * still catch it and complain.  The masking trick does make the hash
+     * noticably faster for short strings (like English words).
+     */
+#ifndef VALGRIND
+
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+    case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+    case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
+    case 6 : b+=k[1]&0xffff; a+=k[0]; break;
+    case 5 : b+=k[1]&0xff; a+=k[0]; break;
+    case 4 : a+=k[0]; break;
+    case 3 : a+=k[0]&0xffffff; break;
+    case 2 : a+=k[0]&0xffff; break;
+    case 1 : a+=k[0]&0xff; break;
+    case 0 : return c;              /* zero length strings require no mixing */
+    }
+
+#else /* make valgrind happy */
+
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=((uint32_t)k8[10])<<16;  /* fall through */
+    case 10: c+=((uint32_t)k8[9])<<8;    /* fall through */
+    case 9 : c+=k8[8];                   /* fall through */
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=((uint32_t)k8[6])<<16;   /* fall through */
+    case 6 : b+=((uint32_t)k8[5])<<8;    /* fall through */
+    case 5 : b+=k8[4];                   /* fall through */
+    case 4 : a+=k[0]; break;
+    case 3 : a+=((uint32_t)k8[2])<<16;   /* fall through */
+    case 2 : a+=((uint32_t)k8[1])<<8;    /* fall through */
+    case 1 : a+=k8[0]; break;
+    case 0 : return c;
+    }
+
+#endif /* !valgrind */
+
+  } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
+    const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
+    const uint8_t  *k8;
+
+    /*--------------- all but last block: aligned reads and different mixing */
+    while (length > 12)
+    {
+      a += k[0] + (((uint32_t)k[1])<<16);
+      b += k[2] + (((uint32_t)k[3])<<16);
+      c += k[4] + (((uint32_t)k[5])<<16);
+      mix(a,b,c);
+      length -= 12;
+      k += 6;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[4]+(((uint32_t)k[5])<<16);
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 11: c+=((uint32_t)k8[10])<<16;     /* fall through */
+    case 10: c+=k[4];
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 9 : c+=k8[8];                      /* fall through */
+    case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 7 : b+=((uint32_t)k8[6])<<16;      /* fall through */
+    case 6 : b+=k[2];
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 5 : b+=k8[4];                      /* fall through */
+    case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 3 : a+=((uint32_t)k8[2])<<16;      /* fall through */
+    case 2 : a+=k[0];
+             break;
+    case 1 : a+=k8[0];
+             break;
+    case 0 : return c;                     /* zero length requires no mixing */
+    }
+
+  } else {                        /* need to read the key one byte at a time */
+    const uint8_t *k = (const uint8_t *)key;
+
+    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      a += ((uint32_t)k[1])<<8;
+      a += ((uint32_t)k[2])<<16;
+      a += ((uint32_t)k[3])<<24;
+      b += k[4];
+      b += ((uint32_t)k[5])<<8;
+      b += ((uint32_t)k[6])<<16;
+      b += ((uint32_t)k[7])<<24;
+      c += k[8];
+      c += ((uint32_t)k[9])<<8;
+      c += ((uint32_t)k[10])<<16;
+      c += ((uint32_t)k[11])<<24;
+      mix(a,b,c);
+      length -= 12;
+      k += 12;
+    }
+
+    /*-------------------------------- last block: affect all 32 bits of (c) */
+    switch(length)                   /* all the case statements fall through */
+    {
+    case 12: c+=((uint32_t)k[11])<<24;
+    case 11: c+=((uint32_t)k[10])<<16;
+    case 10: c+=((uint32_t)k[9])<<8;
+    case 9 : c+=k[8];
+    case 8 : b+=((uint32_t)k[7])<<24;
+    case 7 : b+=((uint32_t)k[6])<<16;
+    case 6 : b+=((uint32_t)k[5])<<8;
+    case 5 : b+=k[4];
+    case 4 : a+=((uint32_t)k[3])<<24;
+    case 3 : a+=((uint32_t)k[2])<<16;
+    case 2 : a+=((uint32_t)k[1])<<8;
+    case 1 : a+=k[0];
+             break;
+    case 0 : return c;
+    }
+  }
+
+  final(a,b,c);
+  return c;
+}
+
+/* Helpers */
+
+#define HASH_INITVAL 1
+#define hash(buf, len)  (hash_t)hashlittle(buf, len, HASH_INITVAL)
+#define hash_struct(buf) hash(buf, sizeof(buf))
+
+#endif /* UTIL_JENKINS_HASH_H */
diff --git a/ctrl/facemgr/src/util/ip_address.h b/ctrl/facemgr/src/util/ip_address.h
new file mode 100644
index 000000000..165394709
--- /dev/null
+++ b/ctrl/facemgr/src/util/ip_address.h
@@ -0,0 +1,321 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file ip_address.h
+ * \brief IP address type support
+ */
+#ifndef UTIL_IP_ADDRESS_H
+#define UTIL_IP_ADDRESS_H
+
+#include <arpa/inet.h>  // inet_ntop
+#ifdef __APPLE__
+#include <libkern/OSByteOrder.h>
+#define __bswap_constant_32(x) OSSwapInt32(x)
+#include <machine/endian.h>
+#else
+#include <endian.h>
+#endif
+#include <errno.h>
+#include <netdb.h> // struct addrinfo
+#include <netinet/in.h> // INET*_ADDRSTRLEN, IN*ADDR_LOOPBACK
+#include <stdlib.h>
+#include <stdio.h> // snprintf
+#include <string.h> // memset
+
+#include "types.h"
+
+#define bytes_to_bits(x) (x * 8)
+#define IPV6_ADDR_LEN 16	/* bytes */
+#define IPV4_ADDR_LEN 4		/* bytes */
+#define IPV6_ADDR_LEN_BITS bytes_to_bits(IPV6_ADDR_LEN)
+#define IPV4_ADDR_LEN_BITS bytes_to_bits(IPV4_ADDR_LEN)
+
+#define IP_MAX_ADDR_LEN IPV6_ADDR_LEN
+
+#define DUMMY_PORT 1234
+
+typedef union {
+    union {
+        struct in_addr as_inaddr;
+        u8 as_u8[4];
+        u16 as_u16[2];
+        u32 as_u32;
+    } v4;
+    union {
+        struct in6_addr as_in6addr;
+        u8 as_u8[16];
+        u16 as_u16[8];
+        u32 as_u32[4];
+        u64 as_u64[2];
+    } v6;
+    u8 buffer[IP_MAX_ADDR_LEN];
+    u8 as_u8[IP_MAX_ADDR_LEN];
+    u16 as_u16[IP_MAX_ADDR_LEN >> 1];
+    u32 as_u32[IP_MAX_ADDR_LEN >> 2];
+    u64 as_u64[IP_MAX_ADDR_LEN >> 3];
+} ip_address_t;
+
+#define MAXSZ_IP4_ADDRESS_ INET_ADDRSTRLEN - 1
+#define MAXSZ_IP6_ADDRESS_ INET6_ADDRSTRLEN - 1
+#define MAXSZ_IP_ADDRESS_ MAXSZ_IP6_ADDRESS_
+#define MAXSZ_IP4_ADDRESS MAXSZ_IP4_ADDRESS_ + 1
+#define MAXSZ_IP6_ADDRESS MAXSZ_IP6_ADDRESS_ + 1
+#define MAXSZ_IP_ADDRESS MAXSZ_IP_ADDRESS_ + 1
+
+typedef struct {
+  int family;
+  ip_address_t address;
+  u8 len;
+} ip_prefix_t;
+
+#define MAXSZ_PREFIX_ MAXSZ_IP_ADDRESS_ + 1 + 3
+#define MAXSZ_PREFIX MAXSZ_PREFIX_ + 1
+
+/* No htonl() with const */
+static const ip_address_t IPV4_LOOPBACK = {
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+    .v4.as_inaddr.s_addr = __bswap_constant_32(INADDR_LOOPBACK),
+#else
+    .v4.as_inaddr.s_addr = INADDR_LOOPBACK,
+#endif
+};
+
+static const ip_address_t IPV6_LOOPBACK = {
+    .v6.as_in6addr = IN6ADDR_LOOPBACK_INIT,
+};
+
+static const ip_address_t IPV4_ANY = {
+    .v4.as_inaddr.s_addr = INADDR_ANY,
+};
+
+static const ip_address_t IPV6_ANY = {
+    .v6.as_in6addr = IN6ADDR_ANY_INIT,
+};
+
+#define IP_ANY(family) (family == AF_INET) ? IPV4_ANY : IPV6_ANY
+
+static const ip_address_t IP_ADDRESS_EMPTY = {
+    .as_u64 = { 0 },
+};
+
+
+#define MAX_PORT 1 << (8 * sizeof(u16))
+#define IS_VALID_PORT(x) ((x > 0) && (x < MAX_PORT))
+
+#define MAXSZ_PORT_ 5
+#define MAXSZ_PORT MAXSZ_PORT_ + 1
+
+#define IS_VALID_FAMILY(x) ((x == AF_INET) || (x == AF_INET6))
+
+static inline
+int
+ip_address_get_family (const char * ip_address)
+{
+  struct addrinfo hint, *res = NULL;
+  int rc;
+
+  memset (&hint, '\0', sizeof hint);
+
+  hint.ai_family = PF_UNSPEC;
+  hint.ai_flags = AI_NUMERICHOST;
+
+  rc = getaddrinfo (ip_address, NULL, &hint, &res);
+  if (rc)
+    {
+      return -1;
+    }
+  rc = res->ai_family;
+  freeaddrinfo (res);
+  return rc;
+}
+
+static inline
+int
+ip_address_len (const ip_address_t * ip_address, int family)
+{
+  return (family == AF_INET6) ? IPV6_ADDR_LEN :
+    (family == AF_INET) ? IPV4_ADDR_LEN : 0;
+}
+
+static inline
+int
+ip_address_ntop (const ip_address_t * ip_address, char *dst, const size_t len,
+		int family)
+{
+  const char * s = inet_ntop (family, ip_address->buffer, dst, len);
+  return (s ? 1 : -1);
+}
+
+/*
+ * Parse ip addresses in presentation format
+ */
+static inline
+int
+ip_address_pton (const char *ip_address_str, ip_address_t * ip_address)
+{
+  int pton_fd;
+  char *addr = strdup (ip_address_str);
+  int family;
+
+
+  family = ip_address_get_family (addr);
+
+  switch (family)
+    {
+    case AF_INET6:
+      pton_fd = inet_pton (AF_INET6, addr, &ip_address->buffer);
+      break;
+    case AF_INET:
+      pton_fd = inet_pton (AF_INET, addr, &ip_address->buffer);
+      break;
+    default:
+      goto ERR;
+    }
+
+  //   0 = not in presentation format
+  // < 0 = other error (use perror)
+  if (pton_fd <= 0)
+    {
+      goto ERR;
+    }
+
+  return 1;
+ERR:
+  free (addr);
+  return -1;
+}
+
+
+
+static inline
+int
+ip_address_snprintf(char * s, size_t size, const ip_address_t * ip_address, int family)
+{
+    size_t len = family == AF_INET ? INET_ADDRSTRLEN : INET6_ADDRSTRLEN;
+    const char * rc = inet_ntop (family, ip_address->buffer, s, len);
+    return rc ? strlen(rc) : -1;
+}
+
+
+static inline
+int
+ip_address_to_sockaddr(const ip_address_t * ip_address,
+		struct sockaddr *sockaddr_address, int family)
+{
+  struct sockaddr_in6 *tmp6 = (struct sockaddr_in6 *) sockaddr_address;
+  struct sockaddr_in *tmp4 = (struct sockaddr_in *) sockaddr_address;
+
+  switch (family)
+    {
+    case AF_INET6:
+      tmp6->sin6_family = AF_INET6;
+      tmp6->sin6_port = DUMMY_PORT;
+      tmp6->sin6_scope_id = 0;
+      memcpy (&tmp6->sin6_addr, ip_address->buffer, IPV6_ADDR_LEN);
+      break;
+    case AF_INET:
+      tmp4->sin_family = AF_INET;
+      tmp4->sin_port = DUMMY_PORT;
+      memcpy (&tmp4->sin_addr, ip_address->buffer, IPV4_ADDR_LEN);
+      break;
+    default:
+      return -1;
+    }
+
+  return 1;
+}
+
+static inline
+int
+ip_address_cmp(const ip_address_t * ip1, const ip_address_t * ip2, int family)
+{
+    return memcmp(ip1, ip2, ip_address_len(ip1, family));
+}
+
+static inline
+int
+ip_address_empty(const ip_address_t * ip)
+{
+    return (memcmp(ip, &IP_ADDRESS_EMPTY, sizeof(IP_ADDRESS_EMPTY)) == 0);
+}
+
+/* Parse IP Prefixes in presentation format (in bits, separated by a slash) */
+static inline
+int
+ip_prefix_pton (const char *ip_address_str, ip_prefix_t * ip_prefix)
+{
+  int pton_fd;
+  char *p;
+  char *eptr;
+  char *addr = strdup (ip_address_str);
+
+  p = strchr (addr, '/');
+  if (!p)
+    {
+      ip_prefix->len = 0;		// until we get the ip address family
+    }
+  else
+    {
+      ip_prefix->len = strtoul (p + 1, &eptr, 10);
+      *p = 0;
+    }
+
+  ip_prefix->family = ip_address_get_family (addr);
+
+  switch (ip_prefix->family)
+    {
+    case AF_INET6:
+      if (ip_prefix->len > IPV6_ADDR_LEN_BITS)
+	goto ERR;
+      pton_fd = inet_pton (AF_INET6, addr, &ip_prefix->address.buffer);
+      break;
+    case AF_INET:
+      if (ip_prefix->len > IPV4_ADDR_LEN_BITS)
+	goto ERR;
+      pton_fd = inet_pton (AF_INET, addr, &ip_prefix->address.buffer);
+      break;
+    default:
+      goto ERR;
+    }
+
+  //   0 = not in presentation format
+  // < 0 = other error (use perror)
+  if (pton_fd <= 0)
+    {
+      goto ERR;
+    }
+
+  return 1;
+ERR:
+  free (addr);
+  return -1;
+}
+
+static inline
+int
+ip_prefix_ntop (const ip_prefix_t * ip_prefix, char *dst, size_t size)
+{
+  char ip_s[MAXSZ_IP_ADDRESS];
+  const char * s = inet_ntop (ip_prefix->family, ip_prefix->address.buffer, ip_s, MAXSZ_IP_ADDRESS);
+  if (!s)
+      return -1;
+  size_t n = snprintf(dst, size, "%s/%d", ip_s, ip_prefix->len);
+
+  return (n > 0 ? 1 : -1);
+}
+
+
+#endif /* UTIL_IP_ADDRESS_H */
diff --git a/ctrl/facemgr/src/util/log.c b/ctrl/facemgr/src/util/log.c
new file mode 100644
index 000000000..54943cf45
--- /dev/null
+++ b/ctrl/facemgr/src/util/log.c
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2017-2019 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 "log.h"
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+log_conf_t log_conf = DEFAULT_LOG_CONF;
+
+#define FMT_DATETIME "%02d-%02d-%04d %02d:%02d:%02d"
+#define FMT_DATETIME_LEN 20
+#define snprintf_nowarn(...) (snprintf(__VA_ARGS__) < 0 ? abort() : (void)0)
+
+
+static char ts[FMT_DATETIME_LEN];
+
+static char *timestamp(void)
+{
+	time_t tv;
+	struct tm *tm;
+
+	time(&tv);
+	tm = localtime(&tv);
+
+        snprintf_nowarn(ts, FMT_DATETIME_LEN, FMT_DATETIME, tm->tm_mday,
+                tm->tm_mon + 1, tm->tm_year + 1900, tm->tm_hour, tm->tm_min,
+                tm->tm_sec);
+	return ts;
+}
+
+void _log_va(int level, const char *fmt, va_list ap)
+{
+	char *prefix;
+  FILE *f = log_conf.log_file ? log_conf.log_file : stdout;
+
+#if 0
+	if (!conf.log_system)
+		return;
+#endif
+
+	if (level > log_conf.log_level)
+		return;
+
+	switch (level) {
+		case LOG_FATAL:
+			prefix = "FATAL: ";
+			break;
+		case LOG_ERROR:
+			prefix = "ERROR: ";
+			break;
+		case LOG_WARN:
+			prefix = "WARNING: ";
+			break;
+		case LOG_INFO:
+			prefix = "";
+			break;
+		case LOG_DEBUG:
+			prefix = "DEBUG: ";
+			break;
+		case LOG_TRACE:
+			prefix = "TRACE: ";
+			break;
+		default:
+			prefix = "";
+			break;
+	}
+
+	fprintf(f, "%s %s", timestamp(), prefix);
+	vfprintf(f, fmt, ap);
+	fprintf(f, "\n");
+#ifdef DEBUG
+	fflush(f);
+#endif
+}
+
+void _log(int level, const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	_log_va(level, fmt, ap);
+	va_end(ap);
+}
+
+#ifdef HAVE_BACKTRACE
+#include <execinfo.h>
+
+void print_trace(void)
+{
+	void *array[32];
+	size_t size;
+
+	size = backtrace(array, 32);
+	fflush(conf.log_file);
+	backtrace_symbols_fd(array, size, fileno(conf.log_file));
+}
+#endif
+
+void fatal(char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	_log_va(LOG_FATAL, fmt, ap);
+	va_end(ap);
+
+#ifdef HAVE_BACKTRACE
+	print_trace();
+#endif
+
+	exit(200);
+}
diff --git a/ctrl/facemgr/src/util/log.h b/ctrl/facemgr/src/util/log.h
new file mode 100644
index 000000000..f1cafba47
--- /dev/null
+++ b/ctrl/facemgr/src/util/log.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UTIL_LOG_H
+#define UTIL_LOG_H
+
+#include <stdarg.h> // va_*
+#include <stdio.h> // FILE
+#include <time.h> // time, localtime
+
+#define LOG_FATAL 0
+#define LOG_ERROR 1
+#define LOG_WARN  2
+#define LOG_INFO  3
+#define LOG_DEBUG 4
+#define LOG_TRACE 5
+
+typedef struct {
+  int log_level;
+  int debug;
+  FILE * log_file;
+} log_conf_t;
+
+#define DEFAULT_LOG_CONF {      \
+    .log_level = LOG_DEBUG,     \
+    .debug = 0,                 \
+    .log_file = NULL,           \
+};
+
+extern log_conf_t log_conf;
+
+#define WITH_DEBUG(BLOCK)                       \
+    if (log_conf.log_level >= LOG_DEBUG)        \
+        BLOCK
+
+#define FATAL(fmt, ...) (_log(LOG_FATAL, fmt, ##__VA_ARGS__ ))
+#define ERROR(fmt, ...) (_log(LOG_ERROR, fmt, ##__VA_ARGS__ ))
+#define WARN(fmt,  ...) (_log(LOG_WARN,  fmt, ##__VA_ARGS__ ))
+#define INFO(fmt,  ...) (_log(LOG_INFO,  fmt, ##__VA_ARGS__ ))
+#define DEBUG(fmt, ...) (_log(LOG_DEBUG, fmt, ##__VA_ARGS__ ))
+#define TRACE(fmt, ...) (_log(LOG_TRACE, fmt, ##__VA_ARGS__ ))
+
+void _log_va(int level, const char *fmt, va_list ap);
+
+void _log(int level, const char *fmt, ...);
+
+void fatal(char *fmt, ...);
+
+#ifdef HAVE_BACKTRACE
+#include <execinfo.h>
+void print_trace(void);
+#endif
+
+#endif // UTIL_LOG_H
diff --git a/ctrl/facemgr/src/util/map.h b/ctrl/facemgr/src/util/map.h
new file mode 100644
index 000000000..2694de2a7
--- /dev/null
+++ b/ctrl/facemgr/src/util/map.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UTIL_MAP_H
+#define UTIL_MAP_H
+
+#include <stdlib.h>
+
+#include "../common.h"
+#include "set.h"
+
+#define ERR_MAP_EXISTS -2
+#define ERR_MAP_NOT_FOUND -3
+
+#define TYPEDEF_MAP_H(NAME, KEY_T, VAL_T)                                       \
+                                                                                \
+typedef struct {                                                                \
+    KEY_T key;                                                                  \
+    VAL_T value;                                                                \
+} NAME ## _pair_t;                                                              \
+                                                                                \
+int NAME ## _pair_cmp(const NAME ## _pair_t * p1, const NAME ## _pair_t * p2);  \
+                                                                                \
+TYPEDEF_SET_H(NAME ## _pair_set, NAME ## _pair_t *)                             \
+                                                                                \
+typedef struct NAME ## _s {                                                     \
+    NAME ## _pair_set_t pair_set;                                               \
+} NAME ## _t;                                                                   \
+                                                                                \
+int NAME ## _initialize(NAME ## _t * map);                                      \
+                                                                                \
+int NAME ## _finalize(NAME ## _t * map);                                        \
+                                                                                \
+NAME ## _t * NAME ## _create();                                                 \
+                                                                                \
+void NAME ## _free(NAME ## _t * map);                                           \
+                                                                                \
+int NAME ## _add(NAME ## _t * map, KEY_T key, const VAL_T value);               \
+                                                                                \
+int NAME ## _remove(NAME ## _t * map, KEY_T key, VAL_T * value);                \
+                                                                                \
+int NAME ## _get(NAME ## _t * map, KEY_T key, VAL_T * value);                   \
+                                                                                \
+void NAME ## _dump(NAME ## _t * map);
+
+
+
+
+#define TYPEDEF_MAP(NAME, KEY_T, VAL_T, CMP, KEY_SNPRINTF, VALUE_SNPRINTF)      \
+                                                                                \
+int                                                                             \
+NAME ## _pair_cmp(const NAME ## _pair_t * p1, const NAME ## _pair_t * p2)       \
+{                                                                               \
+    return (CMP(p1->key, p2->key));                                             \
+}                                                                               \
+                                                                                \
+int                                                                             \
+NAME ## _pair_snprintf(char * buf, size_t size, const NAME ## _pair_t * pair) { \
+    int rc;                                                                     \
+    rc = KEY_SNPRINTF(buf, BUFSIZE/2, (KEY_T)pair->key);                        \
+    if (rc < 0)                                                                 \
+        return rc;                                                              \
+    rc = VALUE_SNPRINTF(buf+rc, BUFSIZE/2, (VAL_T)pair->value);             \
+    return rc;                                                                  \
+}                                                                               \
+                                                                                \
+TYPEDEF_SET(NAME ## _pair_set, NAME ## _pair_t *, NAME ## _pair_cmp, NAME ## _pair_snprintf); \
+                                                                                \
+int                                                                             \
+NAME ## _initialize(NAME ## _t * map)                                           \
+{                                                                               \
+    return NAME ## _pair_set_initialize(&map->pair_set);                        \
+}                                                                               \
+                                                                                \
+int                                                                             \
+NAME ## _finalize(NAME ## _t * map)                                             \
+{                                                                               \
+    return NAME ## _pair_set_finalize(&map->pair_set);                          \
+}                                                                               \
+                                                                                \
+AUTOGENERATE_CREATE_FREE(NAME)                                                  \
+                                                                                \
+int                                                                             \
+NAME ## _add(NAME ## _t * map, KEY_T key, const VAL_T value)                    \
+{                                                                               \
+    int rc;                                                                     \
+                                                                                \
+    /* Create pair */                                                           \
+    NAME ## _pair_t * pair = malloc(sizeof(NAME ## _pair_t));                   \
+    if (!pair)                                                                  \
+        return FACEMGR_FAILURE;                                                 \
+                                                                                \
+    pair->key = key;                                                            \
+    pair->value = (VAL_T)value;                                                 \
+                                                                                \
+    rc = NAME ## _pair_set_get(&map->pair_set, pair, NULL);                     \
+    if (!FACEMGR_IS_ERROR(rc)) {                                                \
+        free(pair);                                                             \
+        return ERR_MAP_EXISTS;                                                  \
+    }                                                                           \
+                                                                                \
+    rc = NAME ## _pair_set_add(&map->pair_set, pair);                           \
+    if (FACEMGR_IS_ERROR(rc)) {                                                 \
+        free(pair);                                                             \
+        return FACEMGR_FAILURE;                                                 \
+    }                                                                           \
+    return FACEMGR_SUCCESS;                                                     \
+}                                                                               \
+                                                                                \
+int                                                                             \
+NAME ## _remove(NAME ## _t * map, KEY_T key, VAL_T * value)                     \
+{                                                                               \
+    NAME ## _pair_t * found, search = { .key = key };                           \
+    int rc = NAME ## _pair_set_remove(&map->pair_set, &search, &found);         \
+    if (FACEMGR_IS_ERROR(rc))                                                   \
+        return ERR_MAP_NOT_FOUND;                                               \
+    *value = found->value;                                                      \
+    return FACEMGR_SUCCESS;                                                     \
+}                                                                               \
+                                                                                \
+int                                                                             \
+NAME ## _get(NAME ## _t * map, KEY_T key, VAL_T * value)                        \
+{                                                                               \
+    NAME ## _pair_t * found, search = { .key = key };                           \
+    int rc = NAME ## _pair_set_get(&map->pair_set, &search, &found);            \
+    if (FACEMGR_IS_ERROR(rc))                                                   \
+        return ERR_MAP_NOT_FOUND;                                               \
+    *value = found->value;                                                      \
+    return FACEMGR_SUCCESS;                                                     \
+}                                                                               \
+                                                                                \
+void                                                                            \
+NAME ## _dump(NAME ## _t * map) {                                               \
+    NAME ## _pair_set_dump(&map->pair_set);                                     \
+}
+
+#endif /* UTIL_MAP_H */
diff --git a/ctrl/facemgr/src/util/policy.c b/ctrl/facemgr/src/util/policy.c
new file mode 100644
index 000000000..6c8651ee3
--- /dev/null
+++ b/ctrl/facemgr/src/util/policy.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file policy.h
+ * \brief Implementation of policy description
+ */
+
+#include <stdio.h>
+#include "policy.h"
+
+const char * policy_tag_str[] = {
+    #define _(x, y) [POLICY_TAG_ ## x] = STRINGIZE(x),
+    foreach_policy_tag
+    #undef _
+};
+
+const char policy_tag_short_str[] = {
+    #define _(x, y) [POLICY_TAG_ ## x] = y,
+    foreach_policy_tag
+    #undef _
+};
+
+const char * policy_state_str[] = {
+    #define _(x) [POLICY_STATE_ ## x] = STRINGIZE(x),
+    foreach_policy_state
+    #undef _
+};
+
+int
+policy_tag_state_snprintf(char * s, size_t size, const policy_tag_state_t * tag_state)
+{
+    char *cur = s;
+    int rc;
+
+    if (tag_state->disabled > 1)
+        return -1;
+
+    rc = snprintf(cur, s + size - cur, "%s%s", (tag_state->disabled == 1) ? "!" : "", policy_state_str[tag_state->state]);
+    if (rc < 0)
+        return rc;
+    cur += rc;
+    if (size != 0 && cur >= s + size)
+        return cur - s;
+
+    return cur - s;
+}
diff --git a/ctrl/facemgr/src/util/policy.h b/ctrl/facemgr/src/util/policy.h
new file mode 100644
index 000000000..e20af6560
--- /dev/null
+++ b/ctrl/facemgr/src/util/policy.h
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/**
+ * \file policy.h
+ * \brief Policy description
+ */
+#ifndef HICN_POLICY_H
+#define HICN_POLICY_H
+
+#include <netinet/in.h> // INET*_ADDRSTRLEN
+#include <string.h> // strcasecmp
+#include "token.h"
+
+/* POLICY TAG */
+
+#define foreach_policy_tag      \
+    /* Interface type */        \
+    _(WIRED, 'E')               \
+    _(WIFI, 'W')                \
+    _(CELLULAR, 'C')            \
+    /* QoS */                   \
+    _(BEST_EFFORT, 'b')         \
+    _(REALTIME, 'r')            \
+    _(MULTIPATH, 'M')           \
+    /* Security */              \
+    _(TRUSTED, 'T')
+
+typedef enum {
+#define _(x, y) POLICY_TAG_ ## x,
+foreach_policy_tag
+#undef _
+    POLICY_TAG_N
+} policy_tag_t;
+
+#define MAXSZ_POLICY_TAG_ 11
+#define MAXSZ_POLICY_TAG MAXSZ_POLICY_TAG_ + 1
+
+extern const char * policy_tag_str[];
+extern const char policy_tag_short_str[];
+
+static inline
+policy_tag_t
+policy_tag_from_str(const char * str)
+{
+#define _(x, y) if (strcasecmp(str, policy_tag_str[POLICY_TAG_ ## x] ) == 0) { return POLICY_TAG_ ## x; } else
+foreach_policy_tag
+#undef _
+    return POLICY_TAG_N;
+}
+
+/* POLICY_TAGS */
+
+typedef int policy_tags_t;
+
+static inline
+void policy_tags_add(policy_tags_t * tags, policy_tag_t tag)
+{
+    *tags |= (1 << tag);
+}
+
+static inline
+void policy_tags_remove(policy_tags_t * tags, policy_tag_t tag)
+{
+    *tags &= ~(1 << tag);
+}
+
+static inline
+int policy_tags_has(policy_tags_t tags, policy_tag_t tag)
+{
+    return tags & (1 << tag);
+}
+
+#define POLICY_TAGS_EMPTY 0
+
+static inline
+int
+policy_tags_snprintf(char * s, size_t size, policy_tags_t tags)
+{
+#define _(x, y) s[POLICY_TAG_ ## x] = policy_tags_has(tags, POLICY_TAG_ ## x) ? y : '.';
+foreach_policy_tag
+#undef _
+    s[POLICY_TAG_N] = '\0';
+    return POLICY_TAG_N + 1;
+}
+
+#define MAXSZ_POLICY_TAGS_ POLICY_TAG_N
+#define MAXSZ_POLICY_TAGS MAXSZ_POLICY_TAGS_ + 1
+
+/* POLICY STATE */
+
+/* TODO vs. weight */
+
+#define foreach_policy_state    \
+    _(NEUTRAL)                  \
+    _(REQUIRE)                  \
+    _(PREFER)                   \
+    _(AVOID)                    \
+    _(PROHIBIT)                 \
+    _(N)
+
+typedef enum {
+#define _(x) POLICY_STATE_ ## x,
+foreach_policy_state
+#undef _
+} policy_state_t;
+
+#define MAXSZ_POLICY_STATE_ 8
+#define MAXSZ_POLICY_STATE MAXSZ_POLICY_STATE_ + 1
+
+extern const char * policy_state_str[];
+
+
+/* POLICY TAG STATE */
+
+typedef struct {
+    policy_state_t state;
+    uint8_t disabled;
+} policy_tag_state_t;
+
+#define MAXSZ_POLICY_TAG_STATE_ 8
+#define MAXSZ_POLICY_TAG_STATE MAXSZ_POLICY_TAG_STATE_ + 1
+
+int policy_tag_state_snprintf(char * s, size_t size, const policy_tag_state_t * tag_state);
+
+
+/* INTERFACE STATS */
+
+typedef struct {
+    float throughput;
+    float latency;
+    float loss_rate;
+} interface_stats_t;
+
+#define INTERFACE_STATS_NONE {                          \
+    .throughput = 0,                                    \
+    .latency = 0,                                       \
+    .loss_rate = 0,                                     \
+}
+
+
+/* POLICY STATS */
+
+typedef struct {
+    interface_stats_t wired;
+    interface_stats_t wifi;
+    interface_stats_t cellular;
+    interface_stats_t all;
+} policy_stats_t;
+
+#define POLICY_STATS_NONE {                     \
+    .wired    = INTERFACE_STATS_NONE,           \
+    .wifi     = INTERFACE_STATS_NONE,           \
+    .cellular = INTERFACE_STATS_NONE,           \
+    .all      = INTERFACE_STATS_NONE,           \
+}
+
+typedef struct {
+    uint32_t num_packets;
+    uint32_t num_bytes;
+    uint32_t num_losses;
+    uint32_t latency_idle;
+} interface_counters_t;
+
+#define INTERFACE_COUNTERS_NONE {               \
+    .num_packets = 0,                           \
+    .num_bytes = 0,                             \
+    .num_losses = 0,                            \
+    .latency_idle = 0,                          \
+}
+
+typedef struct {
+    interface_counters_t wired;
+    interface_counters_t wifi;
+    interface_counters_t cellular;
+    interface_counters_t all;
+    uint64_t last_update;
+} policy_counters_t;
+
+#define POLICY_COUNTERS_NONE (policy_counters_t) {      \
+    .wired    = INTERFACE_COUNTERS_NONE,                \
+    .wifi     = INTERFACE_COUNTERS_NONE,                \
+    .cellular = INTERFACE_COUNTERS_NONE,                \
+    .all      = INTERFACE_COUNTERS_NONE,                \
+    .last_update = 0,                                   \
+}
+
+/* POLICY */
+
+#define APP_NAME_LEN 128
+
+typedef struct {
+    char app_name[APP_NAME_LEN];
+    policy_tag_state_t tags[POLICY_TAG_N];
+    policy_stats_t stats;
+} policy_t;
+
+static const policy_t POLICY_NONE = {
+    .app_name = { 0 },
+    .tags = {
+#define _(x, y) [POLICY_TAG_ ## x] = { POLICY_STATE_NEUTRAL, 0 },
+foreach_policy_tag
+#undef _
+    },
+    .stats = POLICY_STATS_NONE,
+};
+
+
+/* POLICY DESCRIPTION */
+
+#define PFX_STRLEN 4 /* eg. /128 */
+
+typedef struct {
+    int family;
+    union {
+        char ipv4_prefix[INET_ADDRSTRLEN + PFX_STRLEN];
+        char ipv6_prefix[INET6_ADDRSTRLEN + PFX_STRLEN];
+    };
+    policy_t policy;
+} policy_description_t;
+
+#endif /* HICN_POLICY_H */
diff --git a/ctrl/facemgr/src/util/set.h b/ctrl/facemgr/src/util/set.h
new file mode 100644
index 000000000..47a6eeaff
--- /dev/null
+++ b/ctrl/facemgr/src/util/set.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UTIL_SET_H
+#define UTIL_SET_H
+
+#include <search.h>
+#include <string.h>
+#include "token.h"
+#include "../common.h"
+
+#define ERR_SET_EXISTS -2
+#define ERR_SET_NOT_FOUND -3
+
+#define BUFSIZE 80
+
+static inline
+int
+string_snprintf(char * buf, size_t size, const char * s) {
+    return snprintf(buf, size, "%s", s);
+}
+
+static inline
+int
+generic_snprintf(char * buf, size_t size, void * value) {
+    return snprintf(buf, BUFSIZE, "%p", value);
+}
+
+#define TYPEDEF_SET_H(NAME, T)                                          \
+                                                                        \
+typedef struct {                                                        \
+    size_t size;                                                        \
+    void * root;                                                        \
+} NAME ## _t;                                                           \
+                                                                        \
+int NAME ## _initialize(NAME ## _t * set);                              \
+                                                                        \
+int NAME ## _finalize(NAME ## _t * set);                                \
+                                                                        \
+NAME ## _t * NAME ## _create();                                         \
+                                                                        \
+void NAME ## _free(NAME ## _t * set);                                   \
+                                                                        \
+int NAME ## _add(NAME ## _t * set, const T element);                    \
+                                                                        \
+int NAME ## _remove(NAME ## _t * set, const T search, T * element);     \
+                                                                        \
+int NAME ## _get(NAME ## _t * set, const T search, T * element);        \
+                                                                        \
+void NAME ## _dump(NAME ## _t * set);
+
+
+
+
+#define TYPEDEF_SET(NAME, T, CMP, SNPRINTF)                             \
+int                                                                     \
+NAME ## _initialize(NAME ## _t * set)                                   \
+{                                                                       \
+    set->root = NULL;                                                   \
+    set->size = 0;                                                      \
+    return FACEMGR_SUCCESS;                                             \
+}                                                                       \
+                                                                        \
+NO_FINALIZE(NAME);                                                      \
+AUTOGENERATE_CREATE_FREE(NAME);                                         \
+                                                                        \
+int                                                                     \
+NAME ## _add(NAME ## _t * set, const T element)                         \
+{                                                                       \
+    return tsearch(element, &set->root, (cmp_t)CMP)              \
+        ? FACEMGR_SUCCESS : FACEMGR_FAILURE;                            \
+}                                                                       \
+                                                                        \
+int                                                                     \
+NAME ## _remove(NAME ## _t * set, const T search, T * element)          \
+{                                                                       \
+    T * found = tdelete(search, &set->root, (cmp_t)CMP);         \
+    if (found && element)                                               \
+        *element = *found;                                              \
+    return found ? FACEMGR_SUCCESS : ERR_SET_NOT_FOUND;                 \
+}                                                                       \
+                                                                        \
+int                                                                     \
+NAME ## _get(NAME ## _t * set, const T search, T * element)             \
+{                                                                       \
+    T * found = tfind(search, &set->root, (cmp_t)CMP);                  \
+    if (found && element)                                               \
+        *element = *found;                                              \
+    return found ? FACEMGR_SUCCESS : ERR_SET_NOT_FOUND;                 \
+}                                                                       \
+                                                                        \
+void                                                                    \
+__ ## NAME ## _dump_node(const void *nodep, const VISIT which, const int depth) \
+{                                                                       \
+    char buf[BUFSIZE];                                                  \
+    switch (which) {                                                    \
+    case preorder:                                                      \
+        break;                                                          \
+    case postorder:                                                     \
+        break;                                                          \
+    case endorder:                                                      \
+        break;                                                          \
+    case leaf:                                                          \
+        SNPRINTF(buf, BUFSIZE, *(T*)nodep);                             \
+        printf("%s\n", buf);                                            \
+        break;                                                          \
+    }                                                                   \
+}                                                                       \
+                                                                        \
+void                                                                    \
+NAME ## _dump(NAME ## _t * set) {                                       \
+    twalk(set->root, __ ## NAME ## _dump_node);                         \
+}                                                                       \
+
+#endif /* UTIL_SET_H */
diff --git a/ctrl/facemgr/src/util/token.h b/ctrl/facemgr/src/util/token.h
new file mode 100644
index 000000000..43e0a77b2
--- /dev/null
+++ b/ctrl/facemgr/src/util/token.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2017-2019 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.
+ */
+
+/* Token concatenation */
+
+/*
+ * Concatenate preprocessor tokens A and B without expanding macro definitions
+ * (however, if invoked from a macro, macro arguments are expanded).
+ */
+#define PPCAT_NX(A, B) A ## B
+
+/*
+ * Concatenate preprocessor tokens A and B after macro-expanding them.
+ */
+#define PPCAT(A, B) PPCAT_NX(A, B)
+
+/* Token stringification */
+
+/*
+ * Turn A into a string literal without expanding macro definitions
+ * (however, if invoked from a macro, macro arguments are expanded).
+ */
+#define STRINGIZE_NX(A) #A
+
+/*
+ * Turn A into a string literal after macro-expanding it.
+ */
+#define STRINGIZE(A) STRINGIZE_NX(A)
diff --git a/ctrl/facemgr/src/util/types.h b/ctrl/facemgr/src/util/types.h
new file mode 100644
index 000000000..10a0bdca0
--- /dev/null
+++ b/ctrl/facemgr/src/util/types.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UTIL_TYPES
+#define UTIL_TYPES
+
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+
+/* Helper for avoiding warnings about type-punning */
+#define UNION_CAST(x, destType) \
+   (((union {__typeof__(x) a; destType b;})x).b)
+
+typedef unsigned int hash_t;
+
+typedef int (*cmp_t)(const void *, const void *);
+
+/* Enums */
+
+#define IS_VALID_ENUM_TYPE(NAME, x) ((x > NAME ## _UNDEFINED) && (x < NAME ## _N))
+
+#endif /* UTIL_TYPES */